pry 0.10.3 → 0.14.2

data/lib/pry/testable/evalable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Pry
+  module Testable
+    module Evalable
+      def pry_tester(*args, &block)
+        args.unshift(Pry.toplevel_binding) if args.empty? || args[0].is_a?(Hash)
+        Pry::Testable::PryTester.new(*args).tap do |t|
+          t.singleton_class.class_eval(&block) if block
+        end
+      end
+
+      def pry_eval(*eval_strs)
+        b =
+          if eval_strs.first.is_a?(String)
+            Pry.toplevel_binding
+          else
+            Pry.binding_for(eval_strs.shift)
+          end
+        pry_tester(b).eval(*eval_strs)
+      end
+    end
+  end
+end

data/lib/pry/testable/mockable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+class Pry
+  module Testable
+    module Mockable
+      def mock_command(cmd, args = [], opts = {})
+        output = StringIO.new
+        pry = Pry.new(output: output)
+        ret = cmd.new(opts.merge(pry_instance: pry, output: output)).call_safely(*args)
+        Struct.new(:output, :return).new(output.string, ret)
+      end
+
+      def mock_exception(*mock_backtrace)
+        StandardError.new.tap do |e|
+          e.define_singleton_method(:backtrace) { mock_backtrace }
+        end
+      end
+    end
+  end
+end

data/lib/pry/testable/pry_tester.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+class Pry
+  module Testable
+    class PryTester
+      extend Pry::Forwardable
+      attr_reader :pry, :out
+      def_delegators :@pry, :eval_string, :eval_string=
+
+      def initialize(target = TOPLEVEL_BINDING, options = {})
+        @pry = Pry.new(options.merge(target: target))
+        @history = options[:history]
+        @pry.inject_sticky_locals!
+        reset_output
+      end
+
+      def eval(*strs)
+        reset_output
+        result = nil
+
+        strs.flatten.each do |str|
+          # Check for space prefix. See #1369.
+          str = "#{str.strip}\n" if str !~ /^\s\S/
+          @history.push str if @history
+
+          result =
+            if @pry.process_command(str)
+              last_command_result_or_output
+            else
+              # Check if this is a multiline paste.
+              begin
+                complete_expr = Pry::Code.complete_expression?(str)
+              rescue SyntaxError => exception
+                @pry.output.puts(
+                  "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
+                )
+              end
+              @pry.evaluate_ruby(str) if complete_expr
+            end
+        end
+
+        result
+      end
+
+      def push(*lines)
+        Array(lines).flatten.each do |line|
+          @pry.eval(line)
+        end
+      end
+
+      def push_binding(context)
+        @pry.push_binding context
+      end
+
+      def last_output
+        @out.string if @out
+      end
+
+      def process_command(command_str)
+        @pry.process_command(command_str) || raise("Not a valid command")
+        last_command_result_or_output
+      end
+
+      def last_command_result
+        result = Pry.current[:pry_cmd_result]
+        result.retval if result
+      end
+
+      protected
+
+      def last_command_result_or_output
+        result = last_command_result
+        if result != Pry::Command::VOID_VALUE
+          result
+        else
+          last_output
+        end
+      end
+
+      def reset_output
+        @out = StringIO.new
+        @pry.output = @out
+      end
+    end
+  end
+end

data/lib/pry/testable/utility.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+class Pry
+  module Testable
+    module Utility
+      #
+      # Creates a Tempfile then unlinks it after the block has yielded.
+      #
+      # @yieldparam [String] file
+      #   The path of the temp file
+      #
+      # @return [void]
+      #
+      def temp_file(ext = '.rb')
+        file = Tempfile.open(['pry', ext])
+        yield file
+      ensure
+        file.close(true) if file
+      end
+
+      def unindent(*args)
+        Pry::Helpers::CommandHelpers.unindent(*args)
+      end
+
+      def inner_scope
+        catch(:inner_scope) do
+          yield -> { throw(:inner_scope, self) }
+        end
+      end
+    end
+  end
+end

data/lib/pry/testable/variables.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class Pry
+  module Testable
+    module Variables
+      #
+      # @example
+      #   temporary_constants(:Foo, :Bar) do
+      #     Foo = Class.new(RuntimeError)
+      #     Bar = Class.new(RuntimeError)
+      #   end
+      #   Foo # => NameError
+      #   Bar # => NameError
+      #
+      # @param [Array<Symbol>] names
+      #   An array of constant names that be defined by a block,
+      #   and removed by this method afterwards.
+      #
+      # @return [void]
+      #
+      def temporary_constants(*names)
+        names.each do |name|
+          Object.remove_const name if Object.const_defined?(name)
+        end
+        yield
+      ensure
+        names.each do |name|
+          Object.remove_const name if Object.const_defined?(name)
+        end
+      end
+
+      #
+      # @param [String] name
+      #   The name of a variable.
+      #
+      # @param [String] value
+      #   Its value.
+      #
+      # @param [Binding] binding
+      #   The binding object to insert a variable into.
+      #
+      # @return [void]
+      #
+      def insert_variable(name, value, binding)
+        Pry.current[:pry_local] = value
+        binding.eval("#{name} = ::Pry.current[:pry_local]")
+      ensure
+        Pry.current[:pry_local] = nil
+      end
+    end
+  end
+end

data/lib/pry/testable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# good idea ???
+# if you're testing pry plugin you should require pry by yourself, no?
+require 'pry' unless defined?(Pry)
+
+class Pry
+  module Testable
+    require_relative "testable/pry_tester"
+    require_relative "testable/evalable"
+    require_relative "testable/mockable"
+    require_relative "testable/variables"
+    require_relative "testable/utility"
+
+    #
+    # When {Pry::Testable} is included into another module or class,
+    # the following modules are also included: {Pry::Testable::Mockable},
+    # {Pry::Testable::Evalable}, {Pry::Testable::Variables}, and
+    # {Pry::Testable::Utility}.
+    #
+    # @note
+    #   Each of the included modules mentioned above may also be used
+    #   standalone or in a pick-and-mix fashion.
+    #
+    # @param [Module] mod
+    #   A class or module.
+    #
+    # @return [void]
+    #
+    def self.included(mod)
+      mod.module_eval do
+        include Pry::Testable::Mockable
+        include Pry::Testable::Evalable
+        include Pry::Testable::Variables
+        include Pry::Testable::Utility
+      end
+    end
+
+    #
+    # Sets various configuration options that make Pry optimal for a test
+    # environment, see source code for complete details.
+    #
+    # @return [void]
+    #
+    def self.set_testenv_variables
+      Pry.config = Pry::Config.new.merge(
+        color: false,
+        pager: false,
+        should_load_rc: false,
+        should_load_local_rc: false,
+        correct_indent: false,
+        collision_warning: false,
+        history_save: false,
+        history_load: false,
+        hooks: Pry::Hooks.new
+      )
+    end
+
+    #
+    # Reset the Pry configuration to their default values.
+    #
+    # @return [void]
+    #
+    def self.unset_testenv_variables
+      Pry.config = Pry::Config.new
+    end
+  end
+end

data/lib/pry/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
-  VERSION = "0.10.3"
+  VERSION = '0.14.2'.freeze
 end

data/lib/pry/warning.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  # @since v0.13.0
+  module Warning
+    # Prints a warning message with exact file and line location, similar to how
+    # Ruby's -W prints warnings.
+    #
+    # @param [String] message
+    # @return [void]
+    def self.warn(message)
+      location = caller_locations(2..2).first
+      path = location.path
+      lineno = location.lineno
+
+      Kernel.warn("#{path}:#{lineno}: warning: #{message}")
+    end
+  end
+end

data/lib/pry/{module_candidate.rb → wrapped_module/candidate.rb}

@@ -1,36 +1,31 @@
-require 'pry/helpers/documentation_helpers'
-require 'forwardable'
+# frozen_string_literal: true
 
 class Pry
   class WrappedModule
-
     # This class represents a single candidate for a module/class definition.
     # It provides access to the source, documentation, line and file
     # for a monkeypatch (reopening) of a class/module.
     class Candidate
       include Pry::Helpers::DocumentationHelpers
       include Pry::CodeObject::Helpers
-      extend Forwardable
+      extend Pry::Forwardable
 
       # @return [String] The file where the module definition is located.
       attr_reader :file
-      alias_method :source_file, :file
+      alias source_file file
 
       # @return [Fixnum] The line where the module definition is located.
       attr_reader :line
-      alias_method :source_line, :line
+      alias source_line line
 
       # Methods to delegate to associated `Pry::WrappedModule
       # instance`.
-      private_delegates = [:lines_for_file, :method_candidates,
-                           :yard_docs?]
-
-      public_delegates = [:wrapped, :module?, :class?, :name, :nonblank_name,
-                          :number_of_candidates]
+      private_delegates = %i[lines_for_file method_candidates yard_docs? name]
+      public_delegates = %i[wrapped module? class? nonblank_name
+                            number_of_candidates]
 
-      def_delegators :@wrapper, *(private_delegates + public_delegates)
-      private(*private_delegates)
-      public(*public_delegates)
+      def_delegators :@wrapper, *public_delegates
+      def_private_delegators :@wrapper, *private_delegates
 
       # @raise [Pry::CommandError] If `rank` is out of bounds.
       # @param [Pry::WrappedModule] wrapper The associated
@@ -45,10 +40,15 @@ class Pry
 
         if number_of_candidates <= 0
           raise CommandError, "Cannot find a definition for #{name} module!"
-        elsif rank > (number_of_candidates - 1)
-          raise CommandError, "No such module candidate. Allowed candidates range is from 0 to #{number_of_candidates - 1}"
         end
 
+        if rank > (number_of_candidates - 1)
+          raise CommandError,
+                "No such module candidate. Allowed candidates range is " \
+                "from 0 to #{number_of_candidates - 1}"
+        end
+
+        @source = @source_location = nil
         @rank = rank
         @file, @line = source_location
       end
@@ -60,16 +60,17 @@ class Pry
         return nil if file.nil?
         return @source if @source
 
-        @source = strip_leading_whitespace(Pry::Code.from_file(file).expression_at(line, number_of_lines_in_first_chunk))
+        @source ||= strip_leading_whitespace(
+          Pry::Code.from_file(file).expression_at(line, number_of_lines_in_first_chunk)
+        )
       end
 
       # @raise [Pry::CommandError] If documentation cannot be found.
       # @return [String] The documentation for the candidate.
       def doc
         return nil if file.nil?
-        return @doc if @doc
 
-        @doc = get_comment_content(Pry::Code.from_file(file).comment_describing(line))
+        @doc ||= get_comment_content(Pry::Code.from_file(file).comment_describing(line))
       end
 
       # @return [Array, nil] A `[String, Fixnum]` pair representing the
@@ -79,9 +80,9 @@ class Pry
         return @source_location if @source_location
 
         file, line = first_method_source_location
-        return nil if !file.is_a?(String)
+        return nil unless file.is_a?(String)
 
-        @source_location = [file,  first_line_of_module_definition(file, line)]
+        @source_location = [file, first_line_of_module_definition(file, line)]
       rescue Pry::RescuableException
         nil
       end
@@ -97,14 +98,15 @@ class Pry
       #   line number is one-indexed.
       def first_line_of_module_definition(file, line)
         searchable_lines = lines_for_file(file)[0..(line - 2)]
-        searchable_lines.rindex { |v| class_regexes.any? { |r| r =~ v } } + 1
+        searchable_lines.rindex { |v| module_definition_first_line?(v) } + 1
       end
 
-      def class_regexes
+      def module_definition_first_line?(line)
         mod_type_string = wrapped.class.to_s.downcase
-        [/^\s*#{mod_type_string}\s+(?:(?:\w*)::)*?#{wrapped.name.split(/::/).last}/,
-         /^\s*(::)?#{wrapped.name.split(/::/).last}\s*?=\s*?#{wrapped.class}/,
-         /^\s*(::)?#{wrapped.name.split(/::/).last}\.(class|instance)_eval/]
+        wrapped_name_last = wrapped.name.split(/::/).last
+        /(^|=)\s*#{mod_type_string}\s+(?:(?:\w*)::)*?#{wrapped_name_last}/ =~ line ||
+          /^\s*(::)?#{wrapped_name_last}\s*?=\s*?#{wrapped.class}/ =~ line ||
+          /^\s*(::)?#{wrapped_name_last}\.(class|instance)_eval/ =~ line
       end
 
       # This method is used by `Candidate#source_location` as a
@@ -118,14 +120,15 @@ class Pry
       # @return [Array] The source location of the last method in this
       #   candidate's module definition.
       def last_method_source_location
-        @end_method_source_location ||= method_candidates[@rank].last.source_location
+        @last_method_source_location ||= method_candidates[@rank].last.source_location
       end
 
-      # Return the number of lines between the start of the class definition
-      # and the start of the last method. We use this value so we can
-      # quickly grab these lines from the file (without having to
-      # check each intervening line for validity, which is expensive) speeding up source extraction.
-      # @return [Fixum] Number of lines.
+      # Return the number of lines between the start of the class definition and
+      # the start of the last method. We use this value so we can quickly grab
+      # these lines from the file (without having to check each intervening line
+      # for validity, which is expensive) speeding up source extraction.
+      #
+      # @return [Integer] number of lines.
       def number_of_lines_in_first_chunk
         end_method_line = last_method_source_location.last