pry 0.12.2 → 0.13.0

data/lib/pry/commands/edit/exception_patcher.rb

@@ -1,24 +1,28 @@
+# frozen_string_literal: true
+
 class Pry
-  class Command::Edit
-    class ExceptionPatcher
-      attr_accessor :_pry_
-      attr_accessor :state
-      attr_accessor :file_and_line
+  class Command
+    class Edit
+      class ExceptionPatcher
+        attr_accessor :pry_instance
+        attr_accessor :state
+        attr_accessor :file_and_line
 
-      def initialize(_pry_, state, exception_file_and_line)
-        @_pry_ = _pry_
-        @state = state
-        @file_and_line = exception_file_and_line
-      end
+        def initialize(pry_instance, state, exception_file_and_line)
+          @pry_instance = pry_instance
+          @state = state
+          @file_and_line = exception_file_and_line
+        end
 
-      # perform the patch
-      def perform_patch
-        file_name, _ = file_and_line
-        lines = state.dynamical_ex_file || File.read(file_name)
+        # perform the patch
+        def perform_patch
+          file_name, = file_and_line
+          lines = state.dynamical_ex_file || File.read(file_name)
 
-        source = Pry::Editor.new(_pry_).edit_tempfile_with_content(lines)
-        _pry_.evaluate_ruby source
-        state.dynamical_ex_file = source.split("\n")
+          source = Pry::Editor.new(pry_instance).edit_tempfile_with_content(lines)
+          pry_instance.evaluate_ruby source
+          state.dynamical_ex_file = source.split("\n")
+        end
       end
     end
   end

data/lib/pry/commands/edit/file_and_line_locator.rb

@@ -1,34 +1,45 @@
+# frozen_string_literal: true
+
 class Pry
-  class Command::Edit
-    module FileAndLineLocator
-      class << self
-        def from_binding(target)
-          [target.eval("__FILE__"), target.eval("__LINE__")]
-        end
+  class Command
+    class Edit
+      module FileAndLineLocator
+        class << self
+          def from_binding(target)
+            if target.respond_to?(:source_location)
+              target.source_location
+            else
+              target.eval("[__FILE__, __LINE__]")
+            end
+          end
+
+          def from_code_object(code_object, filename_argument)
+            unless File.exist?(code_object.source_file.to_s)
+              raise CommandError, "Cannot find a file for #{filename_argument}!"
+            end
 
-        def from_code_object(code_object, filename_argument)
-          if File.exist?(code_object.source_file.to_s)
             [code_object.source_file, code_object.source_line]
-          else
-            raise CommandError, "Cannot find a file for #{filename_argument}!"
           end
-        end
 
-        def from_exception(exception, backtrace_level)
-          raise CommandError, "No exception found." if exception.nil?
+          def from_exception(exception, backtrace_level)
+            raise CommandError, "No exception found." if exception.nil?
 
-          file_name, line = exception.bt_source_location_for(backtrace_level)
-          raise CommandError, "Exception has no associated file." if file_name.nil?
-          raise CommandError, "Cannot edit exceptions raised in REPL." if Pry.eval_path == file_name
+            file_name, line = exception.bt_source_location_for(backtrace_level)
+            raise CommandError, "Exception has no associated file." if file_name.nil?
 
-          [file_name, line]
-        end
+            if Pry.eval_path == file_name
+              raise CommandError, "Cannot edit exceptions raised in REPL."
+            end
+
+            [file_name, line]
+          end
 
-        # when file and line are passed as a single arg, e.g my_file.rb:30
-        def from_filename_argument(filename_argument)
-          f = File.expand_path(filename_argument)
-          l = f.sub!(/:(\d+)$/, "") ? $1.to_i : 1
-          [f, l]
+          # when file and line are passed as a single arg, e.g my_file.rb:30
+          def from_filename_argument(filename_argument)
+            f = File.expand_path(filename_argument)
+            l = f.sub!(/:(\d+)$/, "") ? Regexp.last_match(1).to_i : 1
+            [f, l]
+          end
         end
       end
     end

data/lib/pry/commands/exit.rb

@@ -1,43 +1,47 @@
+# frozen_string_literal: true
+
 class Pry
-  class Command::Exit < Pry::ClassCommand
-    match 'exit'
-    group 'Navigating Pry'
-    description 'Pop the previous binding.'
-    command_options keep_retval: true
-
-    banner <<-'BANNER'
-      Usage:   exit [OPTIONS] [--help]
-      Aliases: quit
-
-      Pop the previous binding (does NOT exit program). It can be useful to exit a
-      context with a user-provided value. For instance an exit value can be used to
-      determine program flow.
-
-      exit "pry this"
-      exit
-
-      https://github.com/pry/pry/wiki/State-navigation#wiki-Exit_with_value
-    BANNER
-
-    def process
-      if _pry_.binding_stack.one?
-        _pry_.run_command "exit-all #{arg_string}"
-      else
-        # otherwise just pop a binding and return user supplied value
-        process_pop_and_return
+  class Command
+    class Exit < Pry::ClassCommand
+      match 'exit'
+      group 'Navigating Pry'
+      description 'Pop the previous binding.'
+      command_options keep_retval: true
+
+      banner <<-'BANNER'
+        Usage:   exit [OPTIONS] [--help]
+        Aliases: quit
+
+        Pop the previous binding (does NOT exit program). It can be useful to exit a
+        context with a user-provided value. For instance an exit value can be used to
+        determine program flow.
+
+        exit "pry this"
+        exit
+
+        https://github.com/pry/pry/wiki/State-navigation#wiki-Exit_with_value
+      BANNER
+
+      def process
+        if pry_instance.binding_stack.one?
+          pry_instance.run_command "exit-all #{arg_string}"
+        else
+          # otherwise just pop a binding and return user supplied value
+          process_pop_and_return
+        end
       end
-    end
 
-    def process_pop_and_return
-      popped_object = _pry_.binding_stack.pop.eval('self')
+      def process_pop_and_return
+        popped_object = pry_instance.binding_stack.pop.eval('self')
 
-      # return a user-specified value if given otherwise return the object
-      return target.eval(arg_string) unless arg_string.empty?
+        # return a user-specified value if given otherwise return the object
+        return target.eval(arg_string) unless arg_string.empty?
 
-      popped_object
+        popped_object
+      end
     end
-  end
 
-  Pry::Commands.add_command(Pry::Command::Exit)
-  Pry::Commands.alias_command 'quit', 'exit'
+    Pry::Commands.add_command(Pry::Command::Exit)
+    Pry::Commands.alias_command 'quit', 'exit'
+  end
 end

data/lib/pry/commands/exit_all.rb

@@ -1,29 +1,33 @@
+# frozen_string_literal: true
+
 class Pry
-  class Command::ExitAll < Pry::ClassCommand
-    match 'exit-all'
-    group 'Navigating Pry'
-    description 'End the current Pry session.'
+  class Command
+    class ExitAll < Pry::ClassCommand
+      match 'exit-all'
+      group 'Navigating Pry'
+      description 'End the current Pry session.'
 
-    banner <<-'BANNER'
-      Usage:   exit-all [--help]
-      Aliases: !!@
+      banner <<-'BANNER'
+        Usage:   exit-all [--help]
+        Aliases: !!@
 
-      End the current Pry session (popping all bindings and returning to caller).
-      Accepts optional return value.
-    BANNER
+        End the current Pry session (popping all bindings and returning to caller).
+        Accepts optional return value.
+      BANNER
 
-    def process
-      # calculate user-given value
-      exit_value = target.eval(arg_string)
+      def process
+        # calculate user-given value
+        exit_value = target.eval(arg_string)
 
-      # clear the binding stack
-      _pry_.binding_stack.clear
+        # clear the binding stack
+        pry_instance.binding_stack.clear
 
-      # break out of the repl loop
-      throw(:breakout, exit_value)
+        # break out of the repl loop
+        throw(:breakout, exit_value)
+      end
     end
-  end
 
-  Pry::Commands.add_command(Pry::Command::ExitAll)
-  Pry::Commands.alias_command '!!@', 'exit-all'
+    Pry::Commands.add_command(Pry::Command::ExitAll)
+    Pry::Commands.alias_command '!!@', 'exit-all'
+  end
 end

data/lib/pry/commands/exit_program.rb

@@ -1,23 +1,27 @@
+# frozen_string_literal: true
+
 class Pry
-  class Command::ExitProgram < Pry::ClassCommand
-    match 'exit-program'
-    group 'Navigating Pry'
-    description 'End the current program.'
+  class Command
+    class ExitProgram < Pry::ClassCommand
+      match 'exit-program'
+      group 'Navigating Pry'
+      description 'End the current program.'
 
-    banner <<-'BANNER'
-      Usage:   exit-program [--help]
-      Aliases: quit-program
-               !!!
+      banner <<-'BANNER'
+        Usage:   exit-program [--help]
+        Aliases: quit-program
+                 !!!
 
-      End the current program.
-    BANNER
+        End the current program.
+      BANNER
 
-    def process
-      Kernel.exit target.eval(arg_string).to_i
+      def process
+        Kernel.exit target.eval(arg_string).to_i
+      end
     end
-  end
 
-  Pry::Commands.add_command(Pry::Command::ExitProgram)
-  Pry::Commands.alias_command 'quit-program', 'exit-program'
-  Pry::Commands.alias_command '!!!', 'exit-program'
+    Pry::Commands.add_command(Pry::Command::ExitProgram)
+    Pry::Commands.alias_command 'quit-program', 'exit-program'
+    Pry::Commands.alias_command '!!!', 'exit-program'
+  end
 end

data/lib/pry/commands/find_method.rb

@@ -1,191 +1,199 @@
-class Pry
-  class Command::FindMethod < Pry::ClassCommand
-    extend Pry::Helpers::BaseHelpers
-
-    match 'find-method'
-    group 'Context'
-    description 'Recursively search for a method within a Class/Module or the current namespace.'
-    command_options shellwords: false
-
-    banner <<-'BANNER'
-      Usage: find-method  [-n|-c] METHOD [NAMESPACE]
-
-      Recursively search for a method within a Class/Module or the current namespace.
-      Use the `-n` switch (the default) to search for methods whose name matches the
-      given regex. Use the `-c` switch to search for methods that contain the given
-      code.
-
-      # Find all methods whose name match /re/ inside
-      # the Pry namespace. Matches Pry#repl, etc.
-      find-method re Pry
-
-      # Find all methods that contain the code:
-      # output.puts inside the Pry namespace.
-      find-method -c 'output.puts' Pry
-    BANNER
-
-    def options(opt)
-      opt.on :n, :name,    "Search for a method by name"
-      opt.on :c, :content, "Search for a method based on content in Regex form"
-    end
-
-    def process
-      return if args.size < 1
+# frozen_string_literal: true
 
-      klass = search_class
-
-      matches = opts.content? ? content_search(klass) : name_search(klass)
-      show_search_results(matches)
-    end
+class Pry
+  class Command
+    class FindMethod < Pry::ClassCommand
+      extend Pry::Helpers::BaseHelpers
+
+      match 'find-method'
+      group 'Context'
+      description 'Recursively search for a method within a Class/Module or ' \
+                  'the current namespace.'
+      command_options shellwords: false
+
+      banner <<-'BANNER'
+        Usage: find-method  [-n|-c] METHOD [NAMESPACE]
+
+        Recursively search for a method within a Class/Module or the current namespace.
+        Use the `-n` switch (the default) to search for methods whose name matches the
+        given regex. Use the `-c` switch to search for methods that contain the given
+        code.
+
+        # Find all methods whose name match /re/ inside
+        # the Pry namespace. Matches Pry#repl, etc.
+        find-method re Pry
+
+        # Find all methods that contain the code:
+        # output.puts inside the Pry namespace.
+        find-method -c 'output.puts' Pry
+      BANNER
+
+      def options(opt)
+        opt.on :n, :name,    "Search for a method by name"
+        opt.on :c, :content, "Search for a method based on content in Regex form"
+      end
 
-    private
+      def process
+        return if args.empty?
 
-    # @return [Regexp] The pattern to search for.
-    def pattern
-      @pattern ||= ::Regexp.new args[0]
-    end
+        klass = search_class
 
-    # Output the result of the search.
-    #
-    # @param [Array] matches
-    def show_search_results(matches)
-      if matches.empty?
-        output.puts bold("No Methods Matched")
-      else
-        print_matches(matches)
+        matches = opts.content? ? content_search(klass) : name_search(klass)
+        show_search_results(matches)
       end
-    end
 
-    # The class to search for methods.
-    # We only search classes, so if the search object is an
-    # instance, return its class. If no search object is given
-    # search `target_self`.
-    def search_class
-      klass = if args[1]
-                target.eval(args[1])
-              else
-                target_self
-              end
-
-      klass.is_a?(Module) ? klass : klass.class
-    end
-
-    # pretty-print a list of matching methods.
-    #
-    # @param [Array<Method>] matches
-    def print_matches(matches)
-      grouped = matches.group_by(&:owner)
-      order = grouped.keys.sort_by { |x| x.name || x.to_s }
+      private
 
-      order.each do |klass|
-        print_matches_for_class(klass, grouped)
+      # @return [Regexp] The pattern to search for.
+      def pattern
+        @pattern ||= ::Regexp.new args[0]
       end
-    end
 
-    # Print matched methods for a class
-    def print_matches_for_class(klass, grouped)
-      output.puts bold(klass.name)
-      grouped[klass].each do |method|
-        header = method.name_with_owner
-        output.puts header + additional_info(header, method)
+      # Output the result of the search.
+      #
+      # @param [Array] matches
+      def show_search_results(matches)
+        if matches.empty?
+          output.puts bold("No Methods Matched")
+        else
+          print_matches(matches)
+        end
       end
-    end
 
-    # Return the matched lines of method source if `-c` is given or ""
-    # if `-c` was not given
-    def additional_info(header, method)
-      if opts.content?
-        ": " << colorize_code(matched_method_lines(header, method))
-      else
-        ""
+      # The class to search for methods.
+      # We only search classes, so if the search object is an
+      # instance, return its class. If no search object is given
+      # search `target_self`.
+      def search_class
+        klass = if args[1]
+                  target.eval(args[1])
+                else
+                  target_self
+                end
+
+        klass.is_a?(Module) ? klass : klass.class
       end
-    end
 
-    def matched_method_lines(header, method)
-      method.source.split(/\n/).select { |x| x =~ pattern }.join("\n#{' ' * header.length}")
-    end
+      # pretty-print a list of matching methods.
+      #
+      # @param [Array<Method>] matches
+      def print_matches(matches)
+        grouped = matches.group_by(&:owner)
+        order = grouped.keys.sort_by { |x| x.name || x.to_s }
 
-    # Run the given block against every constant in the provided namespace.
-    #
-    # @param [Module] klass The namespace in which to start the search.
-    # @param [Hash<Module,Boolean>] done The namespaces we've already visited (private)
-    # @yieldparam klass Each class/module in the namespace.
-    #
-    def recurse_namespace(klass, done = {}, &block)
-      return if !(Module === klass) || done[klass]
-
-      done[klass] = true
-
-      yield klass
-
-      klass.constants.each do |name|
-        next if klass.autoload?(name)
-
-        begin
-          const = klass.const_get(name)
-        rescue RescuableException
-          # constant loading is an inexact science at the best of times,
-          # this often happens when a constant was .autoload? but someone
-          # tried to load it. It's now not .autoload? but will still raise
-          # a NameError when you access it.
-        else
-          recurse_namespace(const, done, &block)
+        order.each do |klass|
+          print_matches_for_class(klass, grouped)
         end
       end
-    end
 
-    # Gather all the methods in a namespace that pass the given block.
-    #
-    # @param [Module] namespace The namespace in which to search.
-    # @yieldparam [Method] method The method to test
-    # @yieldreturn [Boolean]
-    # @return [Array<Method>]
-    #
-    def search_all_methods(namespace)
-      done = Hash.new { |h,k| h[k] = {} }
-      matches = []
+      # Print matched methods for a class
+      def print_matches_for_class(klass, grouped)
+        output.puts bold(klass.name)
+        grouped[klass].each do |method|
+          header = method.name_with_owner
+          output.puts header + additional_info(header, method)
+        end
+      end
 
-      recurse_namespace(namespace) do |klass|
-        (Pry::Method.all_from_class(klass) + Pry::Method.all_from_obj(klass)).each do |method|
-          next if done[method.owner][method.name]
+      # Return the matched lines of method source if `-c` is given or ""
+      # if `-c` was not given
+      def additional_info(header, method)
+        if opts.content?
+          ': ' + colorize_code(matched_method_lines(header, method))
+        else
+          ""
+        end
+      end
 
-          done[method.owner][method.name] = true
+      def matched_method_lines(header, method)
+        method.source.split(/\n/).select { |x| x =~ pattern }.join(
+          "\n#{' ' * header.length}"
+        )
+      end
 
-          matches << method if yield method
+      # Run the given block against every constant in the provided namespace.
+      #
+      # @param [Module] klass The namespace in which to start the search.
+      # @param [Hash<Module,Boolean>] done The namespaces we've already visited (private)
+      # @yieldparam klass Each class/module in the namespace.
+      #
+      def recurse_namespace(klass, done = {}, &block)
+        return if !klass.is_a?(Module) || done[klass]
+
+        done[klass] = true
+
+        yield klass
+
+        klass.constants.each do |name|
+          next if klass.autoload?(name)
+
+          begin
+            const = klass.const_get(name)
+          rescue RescuableException # rubocop:disable Lint/HandleExceptions
+            # constant loading is an inexact science at the best of times,
+            # this often happens when a constant was .autoload? but someone
+            # tried to load it. It's now not .autoload? but will still raise
+            # a NameError when you access it.
+          else
+            recurse_namespace(const, done, &block)
+          end
         end
       end
 
-      matches
-    end
+      # Gather all the methods in a namespace that pass the given block.
+      #
+      # @param [Module] namespace The namespace in which to search.
+      # @yieldparam [Method] method The method to test
+      # @yieldreturn [Boolean]
+      # @return [Array<Method>]
+      #
+      def search_all_methods(namespace)
+        done = Hash.new { |h, k| h[k] = {} }
+        matches = []
+
+        recurse_namespace(namespace) do |klass|
+          methods = Pry::Method.all_from_class(klass) + Pry::Method.all_from_obj(klass)
+          methods.each do |method|
+            next if done[method.owner][method.name]
+
+            done[method.owner][method.name] = true
+
+            matches << method if yield method
+          end
+        end
 
-    # Search for all methods with a name that matches the given regex
-    # within a namespace.
-    #
-    # @param [Module] namespace The namespace to search
-    # @return [Array<Method>]
-    #
-    def name_search(namespace)
-      search_all_methods(namespace) do |meth|
-        meth.name =~ pattern
+        matches
+      end
+
+      # Search for all methods with a name that matches the given regex
+      # within a namespace.
+      #
+      # @param [Module] namespace The namespace to search
+      # @return [Array<Method>]
+      #
+      def name_search(namespace)
+        search_all_methods(namespace) do |meth|
+          meth.name =~ pattern
+        end
       end
-    end
 
-    # Search for all methods who's implementation matches the given regex
-    # within a namespace.
-    #
-    # @param [Module] namespace The namespace to search
-    # @return [Array<Method>]
-    #
-    def content_search(namespace)
-      search_all_methods(namespace) do |meth|
-        begin
-          meth.source =~ pattern
-        rescue RescuableException
-          false
+      # Search for all methods who's implementation matches the given regex
+      # within a namespace.
+      #
+      # @param [Module] namespace The namespace to search
+      # @return [Array<Method>]
+      #
+      def content_search(namespace)
+        search_all_methods(namespace) do |meth|
+          begin
+            meth.source =~ pattern
+          rescue RescuableException
+            false
+          end
         end
       end
     end
-  end
 
-  Pry::Commands.add_command(Pry::Command::FindMethod)
+    Pry::Commands.add_command(Pry::Command::FindMethod)
+  end
 end