pry 0.12.2 → 0.14.1

data/lib/pry/config.rb

@@ -1,35 +1,317 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
 class Pry
-  # The Pry config.
-  # @api public
-  class Config < Pry::BasicObject
-    # Wraps a block so it can have a name.
-    #
-    # @example
-    #   proc1 = proc {}
-    #   proc2 = Pry::Config::Lazy.new(&proc {})
-    #
-    #   proc1.is_a?(Pry::Config::Lazy)
-    #   #=> false
-    #   proc2.is_a?(Pry::Config::Lazy)
-    #   #=> true
+  # @api private
+  class Config
+    extend Attributable
+
+    # @return [IO, #readline] he object from which Pry retrieves its lines of
+    #   input
+    attribute :input
+
+    # @return [IO, #puts] where Pry should output results provided by {input}
+    attribute :output
+
+    # @return [Pry::CommandSet]
+    attribute :commands
+
+    # @return [Proc] the printer for Ruby expressions (not commands)
+    attribute :print
+
+    # @return [Proc] the printer for exceptions
+    attribute :exception_handler
+
+    # @return [Array] Exception that Pry shouldn't rescue
+    attribute :unrescued_exceptions
+
+    # @deprecated
+    # @return [Array] Exception that Pry shouldn't rescue
+    attribute :exception_whitelist
+
+    # @return [Integer] The number of lines of context to show before and after
+    #   exceptions
+    attribute :default_window_size
+
+    # @return [Pry::Hooks]
+    attribute :hooks
+
+    # @return [Pry::Prompt]
+    attribute :prompt
+
+    # @return [String] The display name that is part of the prompt
+    attribute :prompt_name
+
+    # @return [Array<Object>] the list of objects that are known to have a
+    #   1-line #inspect output suitable for prompt
+    attribute :prompt_safe_contexts
+
+    # If it is a String, then that String is used as the shell
+    # command to invoke the editor.
     #
-    # @api private
-    # @since v0.12.0
-    class Lazy
-      def initialize(&block)
-        @block = block
-      end
+    # If it responds to #call is callable then `file`, `line`, and `reloading`
+    # are passed to it. `reloading` indicates whether Pry will be reloading code
+    # after the shell command returns. All parameters are optional.
+    # @return [String, #call]
+    attribute :editor
+
+    # A string that must precede all commands. For example, if is is
+    # set to "%", the "cd" command must be invoked as "%cd").
+    # @return [String]
+    attribute :command_prefix
+
+    # @return [Boolean]
+    attribute :color
+
+    # @return [Boolean]
+    attribute :pager
+
+    # @return [Boolean] whether the global ~/.pryrc should be loaded
+    attribute :should_load_rc
+
+    # @return [Boolean] whether the local ./.pryrc should be loaded
+    attribute :should_load_local_rc
+
+    # @return [Boolean] whether to load files specified with the -r flag
+    attribute :should_load_requires
+
+    # @return [Boolean] whether to disable edit-method's auto-reloading behavior
+    attribute :disable_auto_reload
+
+    # Whether Pry should trap SIGINT and cause it to raise an Interrupt
+    # exception. This is only useful on JRuby, MRI does this for us.
+    # @return [Boolean]
+    attribute :should_trap_interrupts
+
+    # @return [Pry::History]
+    attribute :history
+
+    # @return [Boolean]
+    attribute :history_save
+
+    # @return [Boolean]
+    attribute :history_load
+
+    # @return [String]
+    attribute :history_file
+
+    # @return [Array<String,Regexp>]
+    attribute :history_ignorelist
+
+    # @return [Array<String>] Ruby files to be required
+    attribute :requires
+
+    # @return [Integer] how many input/output lines to keep in memory
+    attribute :memory_size
+
+    # @return [Proc] The proc that runs system commands
+    attribute :system
+
+    # @return [Boolean]
+    attribute :auto_indent
+
+    # @return [Boolean]
+    attribute :correct_indent
 
-      # @return [Object]
-      def call
-        @block.call
+    # @return [Boolean] whether or not display a warning when a command name
+    #   collides with a method/local in the current context.
+    attribute :collision_warning
+
+    # @return [Hash{Symbol=>Proc}]
+    attribute :extra_sticky_locals
+
+    # @return [#build_completion_proc] a completer to use
+    attribute :completer
+
+    # @return [Boolean] suppresses whereami output on `binding.pry`
+    attribute :quiet
+
+    # @return [Boolean] displays a warning about experience improvement on
+    #   Windows
+    attribute :windows_console_warning
+
+    # @return [Proc]
+    attribute :command_completions
+
+    # @return [Proc]
+    attribute :file_completions
+
+    # @return [Hash]
+    attribute :ls
+
+    # @return [String] a line of code to execute in context before the session
+    #   starts
+    attribute :exec_string
+
+    # @return [String]
+    attribute :output_prefix
+
+    # @return [String]
+    # @since v0.13.0
+    attribute :rc_file
+
+    def initialize
+      merge!(
+        input: MemoizedValue.new { lazy_readline },
+        output: $stdout.tap { |out| out.sync = true },
+        commands: Pry::Commands,
+        prompt_name: 'pry',
+        prompt: Pry::Prompt[:default],
+        prompt_safe_contexts: [String, Numeric, Symbol, nil, true, false],
+        print: Pry::ColorPrinter.method(:default),
+        quiet: false,
+        exception_handler: Pry::ExceptionHandler.method(:handle_exception),
+
+        unrescued_exceptions: [
+          ::SystemExit, ::SignalException, Pry::TooSafeException
+        ],
+
+        exception_whitelist: MemoizedValue.new do
+          output.puts(
+            '[warning] Pry.config.exception_whitelist is deprecated, ' \
+            'please use Pry.config.unrescued_exceptions instead.'
+          )
+          unrescued_exceptions
+        end,
+
+        hooks: Pry::Hooks.default,
+        pager: true,
+        system: Pry::SystemCommandHandler.method(:default),
+        color: Pry::Helpers::BaseHelpers.use_ansi_codes?,
+        default_window_size: 5,
+        editor: Pry::Editor.default,
+        rc_file: default_rc_file,
+        should_load_rc: true,
+        should_load_local_rc: true,
+        should_trap_interrupts: Pry::Helpers::Platform.jruby?,
+        disable_auto_reload: false,
+        command_prefix: '',
+        auto_indent: Pry::Helpers::BaseHelpers.use_ansi_codes?,
+        correct_indent: true,
+        collision_warning: false,
+        output_prefix: '=> ',
+        requires: [],
+        should_load_requires: true,
+        windows_console_warning: true,
+        control_d_handler: Pry::ControlDHandler.method(:default),
+        memory_size: 100,
+        extra_sticky_locals: {},
+        command_completions: proc { commands.keys },
+        file_completions: proc { Dir['.'] },
+        ls: OpenStruct.new(Pry::Command::Ls::DEFAULT_OPTIONS),
+        completer: Pry::InputCompleter,
+        history_save: true,
+        history_load: true,
+        history_file: Pry::History.default_file,
+        history_ignorelist: [],
+        history: MemoizedValue.new do
+          if defined?(input::HISTORY)
+            Pry::History.new(history: input::HISTORY)
+          else
+            Pry::History.new
+          end
+        end,
+        exec_string: ''
+      )
+
+      @custom_attrs = {}
+    end
+
+    def merge!(config_hash)
+      config_hash.each_pair { |attr, value| __send__("#{attr}=", value) }
+      self
+    end
+
+    def merge(config_hash)
+      dup.merge!(config_hash)
+    end
+
+    def []=(attr, value)
+      @custom_attrs[attr.to_s] = Config::Value.new(value)
+    end
+
+    def [](attr)
+      @custom_attrs[attr.to_s].call
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(method_name, *args, &_block)
+      name = method_name.to_s
+
+      if name.end_with?('=')
+        self[name[0..-2]] = args.first
+      elsif @custom_attrs.key?(name)
+        self[name]
       end
     end
+    # rubocop:enable Style/MethodMissingSuper
 
-    include Behavior
+    def respond_to_missing?(method_name, include_all = false)
+      @custom_attrs.key?(method_name.to_s.tr('=', '')) || super
+    end
 
-    def self.shortcuts
-      Convenience::SHORTCUTS
+    def initialize_dup(other)
+      super
+      @custom_attrs = @custom_attrs.dup
+    end
+
+    attr_reader :control_d_handler
+    def control_d_handler=(value)
+      proxy_proc =
+        if value.arity == 2
+          Pry::Warning.warn(
+            "control_d_handler's arity of 2 parameters was deprecated " \
+            '(eval_string, pry_instance). Now it gets passed just 1 ' \
+            'parameter (pry_instance)'
+          )
+          proc do |*args|
+            if args.size == 2
+              value.call(args.first, args[1])
+            else
+              value.call(args.first.eval_string, args.first)
+            end
+          end
+        else
+          proc do |*args|
+            if args.size == 2
+              value.call(args[1])
+            else
+              value.call(args.first)
+            end
+          end
+        end
+      @control_d_handler = proxy_proc
+    end
+
+    private
+
+    def lazy_readline
+      require 'readline'
+      ::Readline
+    rescue LoadError
+      output.puts(
+        "Sorry, you can't use Pry without Readline or a compatible library. \n" \
+        "Possible solutions: \n" \
+        " * Rebuild Ruby with Readline support using `--with-readline` \n" \
+        " * Use the rb-readline gem, which is a pure-Ruby port of Readline \n" \
+        " * Use the pry-coolline gem, a pure-ruby alternative to Readline"
+      )
+      raise
+    end
+
+    def default_rc_file
+      if (pryrc = Pry::Env['PRYRC'])
+        pryrc
+      elsif (xdg_home = Pry::Env['XDG_CONFIG_HOME'])
+        # See XDG Base Directory Specification at
+        # https://standards.freedesktop.org/basedir-spec/basedir-spec-0.8.html
+        xdg_home + '/pry/pryrc'
+      elsif File.exist?(File.expand_path('~/.pryrc'))
+        '~/.pryrc'
+      else
+        '~/.config/pry/pryrc'
+      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

data/lib/pry/forwardable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
   module Forwardable
     require 'forwardable'
@@ -17,7 +19,9 @@ class Pry
           instance_variable_get(target).__send__(private_delegate, *a, &b)
         end
       end
-      class_eval { private(*private_delegates) }
+      class_eval do
+        private(*private_delegates) # rubocop:disable Style/AccessModifierDeclarations
+      end
     end
   end
 end