pry 0.10.3 → 0.14.2

data/lib/pry/config.rb

@@ -1,24 +1,314 @@
-class Pry::Config
-  require_relative 'config/behavior'
-  require_relative 'config/default'
-  require_relative 'config/convenience'
-  include Pry::Config::Behavior
-
-  def self.shortcuts
-    Convenience::SHORTCUTS
-  end
+# frozen_string_literal: true
+
+require 'ostruct'
+
+class Pry
+  # @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.
+    #
+    # 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 [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
+
+    def respond_to_missing?(method_name, include_all = false)
+      @custom_attrs.key?(method_name.to_s.tr('=', '')) || super
+    end
+
+    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
 
-  #
-  # 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
+    def default_rc_file
+      [Pry::Env['PRYRC'],
+       # See XDG Base Directory Specification at
+       # https://specifications.freedesktop.org/basedir-spec/latest/
+       "#{Pry::Env['XDG_CONFIG_HOME']}/pry/pryrc",
+       File.expand_path('~/.pryrc'),
+       File.expand_path('~/.config/pry/pryrc')]
+        .compact
+        .find { |file| File.exist?(file) }
     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
@@ -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`).
@@ -113,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
@@ -125,7 +138,7 @@ class BasicObject
       def __pry__
         ::Kernel.binding
       end
-    EOF
-    self.__pry__
+    METHOD
+    __pry__
   end
 end

data/lib/pry/editor.rb

@@ -1,15 +1,34 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
 class Pry
   class Editor
-    include Pry::Helpers::BaseHelpers
+    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)
+    def edit_tempfile_with_content(initial_content, line = 1)
       temp_file do |f|
         f.puts(initial_content)
         f.flush
@@ -19,58 +38,60 @@ class Pry
       end
     end
 
-    def invoke_editor(file, line, blocking=true)
-      raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless _pry_.config.editor
+    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
 
       editor_invocation = build_editor_invocation_string(file, line, blocking)
       return nil unless editor_invocation
 
-      if jruby?
+      if Helpers::Platform.jruby?
         open_editor_on_jruby(editor_invocation)
       else
         open_editor(editor_invocation)
       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 = if windows?
-                            file.gsub(/\//, '\\')
-                          else
-                            Shellwords.escape(file)
-                          end
-
-        "#{_pry_.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
+        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
 
+    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
@@ -84,7 +105,7 @@ class Pry
         '--nofork' if blocking
       when /^jedit/
         '-wait' if blocking
-      when /^mate/, /^subl/, /^redcar/
+      when /^mate/, /^subl/, /^redcar/, /^code/
         '-w' if blocking
       end
     end
@@ -100,6 +121,8 @@ class Pry
         "+#{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/
@@ -109,8 +132,8 @@ class Pry
       when /^redcar/
         "-l#{line_number} #{file_name}"
       else
-        if windows?
-          "#{file_name}"
+        if Helpers::Platform.windows?
+          file_name.to_s
         else
           "+#{line_number} #{file_name}"
         end
@@ -128,8 +151,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