pry 0.10.4 → 0.14.2

data/lib/pry/exceptions.rb

@@ -1,5 +1,6 @@
-class Pry
+# 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.
@@ -14,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
@@ -24,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
 
@@ -50,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
@@ -69,10 +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

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

data/lib/pry/helpers/base_helpers.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
-
     module BaseHelpers
-
-      module_function
+      extend self
 
       def silence_warnings
         old_verbose = $VERBOSE
@@ -20,38 +20,34 @@ class Pry
       # This is required to introspect methods on objects like Net::HTTP::Get that
       # have overridden the `method` method.
       def safe_send(obj, method, *args, &block)
-        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
+        (obj.is_a?(Module) ? Module : Object).instance_method(method)
+          .bind(obj).call(*args, &block)
       end
-      public :safe_send
 
       def find_command(name, set = Pry::Commands)
         command_match = set.find do |_, command|
-          (listing = command.options[:listing]) == name && listing != nil
+          (listing = command.options[:listing]) == name && !listing.nil?
         end
         command_match.last if command_match
       end
 
       def not_a_real_file?(file)
-        file =~ /(\(.*\))|<.*>/ || file =~ /__unknown__/ || file == "" || file == "-e"
-      end
-
-      def command_dependencies_met?(options)
-        return true if !options[:requires_gem]
-        Array(options[:requires_gem]).all? do |g|
-          Rubygem.installed?(g)
-        end
+        file =~ /^(\(.*\))$|^<.*>$/ || file =~ /__unknown__/ || file == "" || file == "-e"
       end
 
       def use_ansi_codes?
-        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
+        Pry::Helpers::Platform.windows_ansi? ||
+          ((term = Pry::Env['TERM']) && term != "dumb")
       end
 
       def colorize_code(code)
-        CodeRay.scan(code, :ruby).term
+        SyntaxHighlighter.highlight(code)
       end
 
-      def highlight(string, regexp, highlight_color=:bright_yellow)
-        string.gsub(regexp) { |match| "<#{highlight_color}>#{match}</#{highlight_color}>" }
+      def highlight(string, regexp, highlight_color = :bright_yellow)
+        string.gsub(regexp) do |match|
+          "<#{highlight_color}>#{match}</#{highlight_color}>"
+        end
       end
 
       # formatting
@@ -60,53 +56,15 @@ class Pry
         "\e[1m#{text}\e[0m"
       end
 
-      # have fun on the Windows platform.
-      def windows?
-        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-      end
-
-      # are we able to use ansi on windows?
-      def windows_ansi?
-        defined?(Win32::Console) || ENV['ANSICON'] || (windows? && mri_2?)
-      end
-
-      def jruby?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
-      end
-
-      def jruby_19?
-        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
-      end
-
-      def rbx?
-        RbConfig::CONFIG['ruby_install_name'] == 'rbx'
-      end
-
-      def mri?
-        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
-      end
-
-      def mri_19?
-        mri? && RUBY_VERSION =~ /^1\.9/
-      end
-
-      def mri_2?
-        mri? && RUBY_VERSION =~ /^2/
-      end
-
-      def mri_20?
-        mri? && RUBY_VERSION =~ /^2\.0/
-      end
-
-      def mri_21?
-        mri? && RUBY_VERSION =~ /^2\.1/
-      end
-
       # Send the given text through the best available pager (if Pry.config.pager is
       # enabled). Infers where to send the output if used as a mixin.
       # DEPRECATED.
-      def stagger_output(text, out = nil)
-        Pry.new.pager.page text
+      def stagger_output(text, _out = nil)
+        if defined?(pry_instance) && pry_instance
+          pry_instance.pager.page text
+        else
+          Pry.new.pager.page text
+        end
       end
     end
   end

data/lib/pry/helpers/command_helpers.rb

@@ -1,90 +1,84 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
 class Pry
   module Helpers
-
     module CommandHelpers
       include OptionsHelpers
 
-      module_function
+      extend self
 
       # Open a temp file and yield it to the block, closing it after
       # @return [String] The path of the temp file
-      def temp_file(ext='.rb')
+      def temp_file(ext = '.rb')
         file = Tempfile.new(['pry', ext])
-        yield file
+        yield(file)
       ensure
-        file.close(true) if file
+        file.close(true)
       end
 
-      def internal_binding?(target)
-        m = target.eval("::Kernel.__method__").to_s
+      def internal_binding?(context)
+        method_name = context.eval("::Kernel.__method__").to_s
         # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
-        ["__binding__", "__pry__", "class_eval"].include?(m)
+        %w[__binding__ __pry__ class_eval].include?(method_name)
+        # TODO: codehaus is dead, there was no test for this and the
+        # description for the commit doesn't exist. Probably a candidate for
+        # removal so we have a chance to introduce a regression and document it
+        # properly.
       end
 
-      def get_method_or_raise(name, target, opts={}, omit_help=false)
-        meth = Pry::Method.from_str(name, target, opts)
-
-        if name && !meth
-          command_error("The method '#{name}' could not be found.", omit_help, MethodNotFound)
+      def get_method_or_raise(method_name, context, opts = {})
+        method = Pry::Method.from_str(method_name, context, opts)
+        if !method && method_name
+          raise Pry::MethodNotFound, "method '#{method_name}' could not be found."
         end
 
         (opts[:super] || 0).times do
-          if meth.super
-            meth = meth.super
+          if method.super
+            method = method.super
           else
-            command_error("'#{meth.name_with_owner}' has no super method.", omit_help, MethodNotFound)
+            raise Pry::MethodNotFound,
+                  "'#{method.name_with_owner}' has no super method"
           end
         end
 
-        if !meth || (!name && internal_binding?(target))
-          command_error("No method name given, and context is not a method.", omit_help, MethodNotFound)
+        if !method || (!method_name && internal_binding?(context))
+          raise Pry::MethodNotFound,
+                'no method name given, and context is not a method'
         end
 
-        set_file_and_dir_locals(meth.source_file)
-        meth
+        set_file_and_dir_locals(method.source_file)
+        method
       end
 
-      def command_error(message, omit_help, klass=CommandError)
-        message += " Type `#{command_name} --help` for help." unless omit_help
-        raise klass, message
-      end
-
-      # Remove any common leading whitespace from every line in `text`.
-      #
-      # This can be used to make a HEREDOC line up with the left margin, without
+      # Remove any common leading whitespace from every line in `text`. This
+      # can be used to make a HEREDOC line up with the left margin, without
       # sacrificing the indentation level of the source code.
       #
-      # e.g.
-      #   opt.banner unindent <<-USAGE
+      # @example
+      #   opt.banner(unindent(<<-USAGE))
       #     Lorem ipsum dolor sit amet, consectetur adipisicing elit,
       #     sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
       #       "Ut enim ad minim veniam."
       #   USAGE
       #
-      # Heavily based on textwrap.dedent from Python, which is:
-      #   Copyright (C) 1999-2001 Gregory P. Ward.
-      #   Copyright (C) 2002, 2003 Python Software Foundation.
-      #   Written by Greg Ward <gward@python.net>
-      #
-      #   Licensed under <http://docs.python.org/license.html>
-      #   From <http://hg.python.org/cpython/file/6b9f0a6efaeb/Lib/textwrap.py>
-      #
-      # @param [String] text The text from which to remove indentation
-      # @return [String] The text with indentation stripped.
-      def unindent(text, left_padding = 0)
-        # Empty blank lines
-        text = text.sub(/^[ \t]+$/, '')
-
-        # Find the longest common whitespace to all indented lines
-        # Ignore lines containing just -- or ++ as these seem to be used by
-        # comment authors as delimeters.
-        margin = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/).inject do |current_margin, next_indent|
+      # @param [String] dirty_text The text from which to remove indentation
+      # @return [String] the text with indentation stripped
+      def unindent(dirty_text, left_padding = 0)
+        text = dirty_text.sub(/\A[ \t]+\z/, '') # Empty blank lines.
+
+        # Find the longest common whitespace to all indented lines. Ignore lines
+        # containing just -- or ++ as these seem to be used by comment authors
+        # as delimeters.
+        scanned_text = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/)
+        margin = scanned_text.inject do |current_margin, next_indent|
           if next_indent.start_with?(current_margin)
             current_margin
           elsif current_margin.start_with?(next_indent)
             next_indent
           else
-            ""
+            ''
           end
         end
 
@@ -93,7 +87,7 @@ class Pry
 
       # Restrict a string to the given range of lines (1-indexed)
       # @param [String] content The string.
-      # @param [Range, Fixnum] lines The line(s) to restrict it to.
+      # @param [Range, Integer] lines The line(s) to restrict it to.
       # @return [String] The resulting string.
       def restrict_to_lines(content, lines)
         line_range = one_index_range_or_number(lines)
@@ -101,11 +95,7 @@ class Pry
       end
 
       def one_index_number(line_number)
-        if line_number > 0
-          line_number - 1
-        else
-          line_number
-        end
+        line_number > 0 ? line_number - 1 : line_number
       end
 
       # convert a 1-index range to a 0-indexed one
@@ -142,15 +132,15 @@ class Pry
         Range.new(a, b)
       end
 
-      def set_file_and_dir_locals(file_name, _pry_=_pry_(), target=target())
-        return if !target or !file_name
-        _pry_.last_file = File.expand_path(file_name)
-        _pry_.inject_local("_file_", _pry_.last_file, target)
+      def set_file_and_dir_locals(file_name, pry = pry_instance, ctx = target)
+        return if !ctx || !file_name
+
+        pry.last_file = File.expand_path(file_name)
+        pry.inject_local("_file_", pry.last_file, ctx)
 
-        _pry_.last_dir = File.dirname(_pry_.last_file)
-        _pry_.inject_local("_dir_", _pry_.last_dir, target)
+        pry.last_dir = File.dirname(pry.last_file)
+        pry.inject_local("_dir_", pry.last_dir, ctx)
       end
     end
-
   end
 end

data/lib/pry/helpers/documentation_helpers.rb

@@ -1,20 +1,30 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
-
     # This class contains methods useful for extracting
     # documentation from methods and classes.
     module DocumentationHelpers
+      YARD_TAGS = %w[
+        param return option yield attr attr_reader attr_writer deprecate example
+        raise
+      ].freeze
 
       module_function
 
       def process_rdoc(comment)
         comment = comment.dup
-        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
-          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
-          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
-          gsub(/\B\+(\w+?)\+\B/)  { "\e[32m#{$1}\e[0m" }.
-          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { CodeRay.scan($1, :ruby).term }.
-          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }
+        last_match_ruby = proc do
+          SyntaxHighlighter.highlight(Regexp.last_match(1))
+        end
+
+        comment.gsub(%r{<code>(?:\s*\n)?(.*?)\s*</code>}m, &last_match_ruby)
+          .gsub(%r{<em>(?:\s*\n)?(.*?)\s*</em>}m) { "\e[1m#{Regexp.last_match(1)}\e[0m" }
+          .gsub(%r{<i>(?:\s*\n)?(.*?)\s*</i>}m) { "\e[1m#{Regexp.last_match(1)}\e[0m" }
+          .gsub(%r{<tt>(?:\s*\n)?(.*?)\s*</tt>}m, &last_match_ruby)
+          .gsub(/\B\+(\w+?)\+\B/) { "\e[32m#{Regexp.last_match(1)}\e[0m" }
+          .gsub(/((?:^[ \t]+(?:(?!.+\e\[)).+(?:\n+|\Z))+)/, &last_match_ruby)
+          .gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{last_match_ruby.call}`" }
       end
 
       def process_yardoc_tag(comment, tag)
@@ -33,10 +43,9 @@ class Pry
       end
 
       def process_yardoc(comment)
-        yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
-                     "deprecate", "example", "raise"]
-        (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
-          gsub(/^@(#{yard_tags.join("|")})/) { "\e[33m#{$1}\e[0m" }
+        (YARD_TAGS - %w[example])
+          .inject(comment) { |a, v| process_yardoc_tag(a, v) }
+          .gsub(/^@(#{YARD_TAGS.join("|")})/) { "\e[33m#{Regexp.last_match(1)}\e[0m" }
       end
 
       def process_comment_markup(comment)
@@ -46,7 +55,7 @@ class Pry
       # @param [String] code
       # @return [String]
       def strip_comments_from_c_code(code)
-        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
+        code.sub(%r{\A\s*/\*.*?\*/\s*}m, '')
       end
 
       # Given a string that makes up a comment in a source-code file parse out the content

data/lib/pry/helpers/options_helpers.rb

@@ -1,26 +1,33 @@
+# frozen_string_literal: true
+
 class Pry
   module Helpers
     module OptionsHelpers
       module_function
 
-      # Add method options to the Slop instance
+      # Add method options to the Pry::Slop instance
       def method_options(opt)
         @method_target = target
         opt.on :M, "instance-methods", "Operate on instance methods."
         opt.on :m, :methods, "Operate on methods."
-        opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors.", :as => :count
-        opt.on :c, :context, "Select object context to run under.", :argument => true do |context|
+        opt.on :s, :super, "Select the 'super' method. Can be repeated to " \
+                           "traverse the ancestors.", as: :count
+        opt.on(
+          :c, :context, "Select object context to run under.", argument: true
+        ) do |context|
           @method_target = Pry.binding_for(target.eval(context))
         end
       end
 
       # Get the method object parsed by the slop instance
       def method_object
-        @method_object ||= get_method_or_raise(args.empty? ? nil : args.join(" "), @method_target,
-                            :super => opts[:super],
-                            :instance => opts.present?(:'instance-methods') && !opts.present?(:'methods'),
-                            :methods  => opts.present?(:'methods') && !opts.present?(:'instance-methods')
-                           )
+        @method_object ||= get_method_or_raise(
+          args.empty? ? nil : args.join(" "),
+          @method_target,
+          super: opts[:super],
+          instance: opts.present?(:'instance-methods') && !opts.present?(:methods),
+          methods: opts.present?(:methods) && !opts.present?(:'instance-methods')
+        )
       end
     end
   end

data/lib/pry/helpers/platform.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+class Pry
+  module Helpers
+    # Contains methods for querying the platform that Pry is running on
+    # @api public
+    # @since v0.12.0
+    module Platform
+      # @return [Boolean]
+      def self.mac_osx?
+        !!(RbConfig::CONFIG['host_os'] =~ /\Adarwin/i)
+      end
+
+      # @return [Boolean]
+      def self.linux?
+        !!(RbConfig::CONFIG['host_os'] =~ /linux/i)
+      end
+
+      # @return [Boolean] true when Pry is running on Windows with ANSI support,
+      #   false otherwise
+      def self.windows?
+        !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/)
+      end
+
+      # @return [Boolean]
+      def self.windows_ansi?
+        return false unless windows?
+
+        !!(defined?(Win32::Console) || Pry::Env['ANSICON'] || mri?)
+      end
+
+      # @return [Boolean]
+      def self.jruby?
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
+      end
+
+      # @return [Boolean]
+      def self.jruby_19?
+        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
+      end
+
+      # @return [Boolean]
+      def self.mri?
+        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
+      # @return [Boolean]
+      def self.mri_2?
+        mri? && RUBY_VERSION.start_with?('2')
+      end
+    end
+  end
+end