pry 0.10.pre.1-java → 0.10.0.pre2-java

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

@@ -0,0 +1,25 @@
+class Pry
+  class Command::Edit
+    class ExceptionPatcher
+      attr_accessor :_pry_
+      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
+
+      # 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")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+class Pry
+  class Command::Edit
+    module FileAndLineLocator
+      class << self
+        def from_binding(target)
+          [target.eval("__FILE__"), target.eval("__LINE__")]
+        end
+
+        def from_code_object(code_object, filename_argument)
+          if File.exists?(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?
+
+          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]
+        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]
+        end
+      end
+    end
+  end
+end

data/lib/pry/commands/exit.rb

@@ -0,0 +1,42 @@
+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
+      end
+    end
+
+    def process_pop_and_return
+      popped_object = _pry_.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?
+      popped_object
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Exit)
+  Pry::Commands.alias_command 'quit', 'exit'
+end

data/lib/pry/commands/exit_all.rb

@@ -0,0 +1,29 @@
+class Pry
+  class Command::ExitAll < Pry::ClassCommand
+    match 'exit-all'
+    group 'Navigating Pry'
+    description 'End the current Pry session.'
+
+    banner <<-'BANNER'
+      Usage:   exit-all [--help]
+      Aliases: !!@
+
+      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)
+
+      # clear the binding stack
+      _pry_.binding_stack.clear
+
+      # break out of the repl loop
+      throw(:breakout, exit_value)
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ExitAll)
+  Pry::Commands.alias_command '!!@', 'exit-all'
+end

data/lib/pry/commands/exit_program.rb

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

data/lib/pry/commands/find_method.rb

@@ -0,0 +1,193 @@
+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 namepsace.
+      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
+      klass = search_class
+
+      matches = if opts.content?
+        content_search(klass)
+      else
+        name_search(klass)
+      end
+
+      show_search_results(matches)
+    end
+
+    private
+
+    # @return [Regexp] The pattern to search for.
+    def pattern
+      @pattern ||= ::Regexp.new args[0]
+    end
+
+    # Output the result of the search.
+    #
+    # @param [Array] matches
+    def show_search_results(matches)
+      if matches.empty?
+        output.puts text.bold("No Methods Matched")
+      else
+        print_matches(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 }
+
+      order.each do |klass|
+        print_matches_for_class(klass, grouped)
+      end
+    end
+
+    # Print matched methods for a class
+    def print_matches_for_class(klass, grouped)
+      output.puts text.bold(klass.name)
+      grouped[klass].each do |method|
+        header = method.name_with_owner
+        output.puts header + additional_info(header, method)
+      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
+        ""
+      end
+    end
+
+    def matched_method_lines(header, method)
+      method.source.split(/\n/).select {|x| x =~ pattern }.join("\n#{' ' * header.length}")
+    end
+
+    # 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)
+        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 = []
+
+      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]
+          done[method.owner][method.name] = true
+
+          matches << method if yield method
+        end
+      end
+
+      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
+
+    # 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
+
+  Pry::Commands.add_command(Pry::Command::FindMethod)
+end

data/lib/pry/commands/fix_indent.rb

@@ -0,0 +1,19 @@
+class Pry
+  class Command::FixIndent < Pry::ClassCommand
+    match 'fix-indent'
+    group 'Input and Output'
+
+    description "Correct the indentation for contents of the input buffer"
+
+    banner <<-USAGE
+      Usage: fix-indent
+    USAGE
+
+    def process
+      indented_str = Pry::Indent.indent(eval_string)
+      eval_string.replace indented_str
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::FixIndent)
+end

data/lib/pry/commands/gem_cd.rb

@@ -0,0 +1,26 @@
+class Pry
+  class Command::GemCd < Pry::ClassCommand
+    match 'gem-cd'
+    group 'Gems'
+    description "Change working directory to specified gem's directory."
+    command_options :argument_required => true
+
+    banner <<-'BANNER'
+      Usage: gem-cd GEM_NAME
+
+      Change the current working directory to that in which the given gem is
+      installed.
+    BANNER
+
+    def process(gem)
+      Dir.chdir(Rubygem.spec(gem).full_gem_path)
+      output.puts(Dir.pwd)
+    end
+
+    def complete(str)
+      Rubygem.complete(str)
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::GemCd)
+end

data/lib/pry/commands/gem_install.rb

@@ -0,0 +1,32 @@
+class Pry
+  class Command::GemInstall < Pry::ClassCommand
+    match 'gem-install'
+    group 'Gems'
+    description 'Install a gem and refresh the gem cache.'
+    command_options :argument_required => true
+
+    banner <<-'BANNER'
+      Usage: gem-install GEM_NAME
+
+      Installs the given gem, refreshes the gem cache, and requires the gem for you
+      based on a best guess from the gem name.
+
+      gem-install pry-stack_explorer
+    BANNER
+
+    def setup
+      require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
+    end
+
+    def process(gem)
+      Rubygem.install(gem)
+      output.puts "Gem `#{ text.green(gem) }` installed."
+      require gem
+    rescue LoadError
+      require_path = gem.split('-').join('/')
+      require require_path
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::GemInstall)
+end

data/lib/pry/commands/gem_list.rb

@@ -0,0 +1,33 @@
+class Pry
+  class Command::GemList < Pry::ClassCommand
+    match 'gem-list'
+    group 'Gems'
+    description 'List and search installed gems.'
+
+    banner <<-'BANNER'
+      Usage: gem-list [REGEX]
+
+      List all installed gems, when a regex is provided, limit the output to those
+      that match the regex.
+    BANNER
+
+    def process(pattern = nil)
+      pattern = Regexp.compile(pattern || '')
+      gems    = Rubygem.list(pattern).group_by(&:name)
+
+      gems.each do |gem, specs|
+        specs.sort! do |a,b|
+          Gem::Version.new(b.version) <=> Gem::Version.new(a.version)
+        end
+
+        versions = specs.each_with_index.map do |spec, index|
+          index == 0 ? text.bright_green(spec.version.to_s) : text.green(spec.version.to_s)
+        end
+
+        output.puts "#{text.default gem} (#{versions.join ', '})"
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::GemList)
+end