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

data/lib/pry/exceptions.rb

@@ -0,0 +1,77 @@
+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.
+  module RescuableException
+    def self.===(exception)
+      case exception
+        # Catch when the user hits ^C (Interrupt < SignalException), and assume
+        # that they just wanted to stop the in-progress command (just like bash
+        # etc.)
+      when Interrupt
+        true
+        # 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
+        false
+        # All other exceptions will be caught.
+      else
+        true
+      end
+    end
+  end
+
+  # Catches SecurityErrors if $SAFE is set
+  module Pry::TooSafeException
+    def self.===(exception)
+      $SAFE > 0 && SecurityError === exception
+    end
+  end
+
+  # An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error
+  # in a more user-friendly manner. This should be used when the exception
+  # happens within Pry itself as a direct consequence of the user typing
+  # something wrong.
+  #
+  # This allows us to distinguish between the user typing:
+  #
+  # pry(main)> def )
+  # SyntaxError: unexpected )
+  #
+  # pry(main)> method_that_evals("def )")
+  # SyntaxError: (eval):1: syntax error, unexpected ')'
+  # from ./a.rb:2 in `eval'
+  module UserError; end
+
+  # When we try to get a binding for an object, we try to define a method on
+  # that Object's singleton class. This doesn't work for "frozen" Object's, and
+  # the exception is just a vanilla RuntimeError.
+  module FrozenObjectException
+    def self.===(exception)
+      ["can't modify frozen class/module",
+       "can't modify frozen Class",
+      ].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
+  class MethodNotFound < CommandError; end
+
+  # 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/helpers.rb

@@ -2,3 +2,4 @@ require "pry/helpers/base_helpers"
 require "pry/helpers/options_helpers"
 require "pry/helpers/command_helpers"
 require "pry/helpers/text"
+require "pry/helpers/table"

data/lib/pry/helpers/base_helpers.rb

@@ -15,16 +15,20 @@ class Pry
         end
       end
 
-      def find_command(name)
-        command_match = commands.find { |_, command| command.options[:listing] == name }
-
-        return command_match.last if command_match
-        nil
-      end
-
-      def gem_installed?(gem_name)
-        require 'rubygems'
-        Gem::Specification.respond_to?(:find_all_by_name) ? !Gem::Specification.find_all_by_name(gem_name).empty? : Gem.source_index.find_name(gem_name).first
+      # Acts like send but ignores any methods defined below Object or Class in the
+      # inheritance hierarchy.
+      # 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)
+      end
+      public :safe_send
+
+      def find_command(name, set = Pry::Commands)
+        command_match = set.find do |_, command|
+          (listing = command.options[:listing]) == name && listing != nil
+        end
+        command_match.last if command_match
       end
 
       def not_a_real_file?(file)
@@ -34,51 +38,16 @@ class Pry
       def command_dependencies_met?(options)
         return true if !options[:requires_gem]
         Array(options[:requires_gem]).all? do |g|
-          gem_installed?(g)
-        end
-      end
-
-      def set_file_and_dir_locals(file_name)
-        return if !target or !file_name
-        _pry_.last_file = File.expand_path(file_name)
-        _pry_.inject_local("_file_", _pry_.last_file, target)
-
-        _pry_.last_dir = File.dirname(_pry_.last_file)
-        _pry_.inject_local("_dir_", _pry_.last_dir, target)
-      end
-
-      def stub_proc(name, options)
-        gems_needed = Array(options[:requires_gem])
-        gems_not_installed = gems_needed.select { |g| !gem_installed?(g) }
-        proc do
-          output.puts "\nThe command '#{name}' requires the following gems to be installed: #{(gems_needed.join(", "))}"
-          output.puts "-"
-          output.puts "Command not available due to dependency on gems: `#{gems_not_installed.join(", ")}` not being met."
-          output.puts "-"
-          output.puts "Type `install #{name}` to install the required gems and activate this command."
-        end
-      end
-
-      def create_command_stub(names, description, options, block)
-        Array(names).each do |name|
-          commands[name] = {
-            :description => "Not available. Execute #{(name)} command for more information.",
-            :action => stub_proc(name, options),
-            :stub_info => options
-          }
+          Rubygem.installed?(g)
         end
       end
 
       def use_ansi_codes?
-         windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
+        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
       end
 
       def colorize_code(code)
-        if Pry.color
-          CodeRay.scan(code, :ruby).term
-        else
-          code
-        end
+        CodeRay.scan(code, :ruby).term
       end
 
       def highlight(string, regexp, highlight_color=:bright_yellow)
@@ -88,11 +57,7 @@ class Pry
       # formatting
       def heading(text)
         text = "#{text}\n--"
-        Pry.color ? "\e[1m#{text}\e[0m": text
-      end
-
-      def page_size
-        27
+        "\e[1m#{text}\e[0m"
       end
 
       # have fun on the Windows platform.
@@ -102,126 +67,47 @@ class Pry
 
       # are we able to use ansi on windows?
       def windows_ansi?
-        defined?(Win32::Console) || ENV['ANSICON']
+        defined?(Win32::Console) || ENV['ANSICON'] || (windows? && mri_2?)
       end
 
-      # are we on Jruby platform?
       def jruby?
         RbConfig::CONFIG['ruby_install_name'] == 'jruby'
       end
 
-      # are we on rbx platform?
+      def jruby_19?
+        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
+      end
+
       def rbx?
         RbConfig::CONFIG['ruby_install_name'] == 'rbx'
       end
 
-      def mri_18?
-        RUBY_VERSION =~ /1.8/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      def mri?
+        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
       end
 
       def mri_19?
-        RUBY_VERSION =~ /1.9/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
-      end
-
-      # a simple pager for systems without `less`. A la windows.
-      def simple_pager(text, output=output())
-        text_array = text.lines.to_a
-        text_array.each_slice(page_size) do |chunk|
-          output.puts chunk.join
-          break if chunk.size < page_size
-          if text_array.size > page_size
-            output.puts "\n<page break> --- Press enter to continue ( q<enter> to break ) --- <page break>"
-            break if $stdin.gets.chomp == "q"
-          end
-        end
+        mri? && RUBY_VERSION =~ /^1\.9/
       end
 
-      # Try to use `less` for paging, if it fails then use
-      # simple_pager. Also do not page if Pry.pager is falsey
-      # FIXME! Another JRuby hack
-      def stagger_output(text, out = nil)
-        out ||= case
-        when respond_to?(:output)
-          # Mixin.
-          output
-        when Pry.respond_to?(:output)
-          # Parent.
-          Pry.output
-        else
-          # Sys.
-          $stdout
-        end
-
-        if text.lines.count < page_size || !Pry.pager
-          out.puts text
-          return
-        end
-
-        # FIXME! Another JRuby hack
-        if jruby?
-          simple_pager(text, out)
-        else
-          lesspipe { |less| less.puts text }
-        end
-      rescue Errno::ENOENT
-        simple_pager(text, out)
-      rescue Errno::EPIPE
-      end
-
-      #
-      # Create scrollable output via less!
-      #
-      # This command runs `less` in a subprocess, and gives you the IO to its STDIN pipe
-      # so that you can communicate with it.
-      #
-      # Example:
-      #
-      #   lesspipe do |less|
-      #     50.times { less.puts "Hi mom!" }
-      #   end
-      #
-      # The default less parameters are:
-      # * Allow colour
-      # * Don't wrap lines longer than the screen
-      # * Quit immediately (without paging) if there's less than one screen of text.
-      #
-      # You can change these options by passing a hash to `lesspipe`, like so:
-      #
-      #   lesspipe(:wrap=>false) { |less| less.puts essay.to_s }
-      #
-      # It accepts the following boolean options:
-      #    :color  => Allow ANSI colour codes?
-      #    :wrap   => Wrap long lines?
-      #    :always => Always page, even if there's less than one page of text?
-      #
-      def lesspipe(*args)
-        if args.any? and args.last.is_a?(Hash)
-          options = args.pop
-        else
-          options = {}
-        end
+      def mri_2?
+        mri? && RUBY_VERSION =~ /^2/
+      end
 
-        output = args.first if args.any?
+      def mri_20?
+        mri? && RUBY_VERSION =~ /^2\.0/
+      end
 
-        params = []
-        params << "-R" unless options[:color] == false
-        params << "-S" unless options[:wrap] == true
-        params << "-F" unless options[:always] == true
-        if options[:tail] == true
-          params << "+\\>"
-          $stderr.puts "Seeking to end of stream..."
-        end
-        params << "-X"
-
-        IO.popen("less #{params * ' '}", "w") do |less|
-          if output
-            less.puts output
-          else
-            yield less
-          end
-        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
+      end
     end
   end
 end

data/lib/pry/helpers/command_helpers.rb

@@ -15,53 +15,29 @@ class Pry
         file.close(true) if file
       end
 
-      def render_output(str, opts={})
-        if opts[:flood]
-          output.puts str
-        else
-          stagger_output str
-        end
-      end
-
-      # Return the file and line for a Binding.
-      # @param [Binding] target The binding
-      # @return [Array] The file and line
-      def file_and_line_from_binding(target)
-        file = target.eval('__FILE__')
-        line_num = target.eval('__LINE__')
-        if rbx?
-          if !target.instance_variable_defined?(:@__actual_file__)
-            target.instance_variable_set(:@__actual_file__, RbxPath.convert_path_to_full(target.variables.method.file.to_s))
-          end
-          file = target.instance_variable_get(:@__actual_file__).to_s
-        end
-
-        [file, line_num]
-      end
-
       def internal_binding?(target)
-        m = target.eval("__method__").to_s
+        m = target.eval("::Kernel.__method__").to_s
         # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
-        ["__binding__", "__binding_impl__", "class_eval"].include?(m)
+        ["__binding__", "__pry__", "class_eval"].include?(m)
       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)
+          command_error("The method '#{name}' could not be found.", omit_help, MethodNotFound)
         end
 
         (opts[:super] || 0).times do
           if meth.super
             meth = meth.super
           else
-            command_error("'#{meth.name_with_owner}' has no super method.", omit_help)
+            command_error("'#{meth.name_with_owner}' has no super method.", omit_help, MethodNotFound)
           end
         end
 
         if !meth || (!name && internal_binding?(target))
-          command_error("No method name given, and context is not a method.", omit_help, NonMethodContextError)
+          command_error("No method name given, and context is not a method.", omit_help, MethodNotFound)
         end
 
         set_file_and_dir_locals(meth.source_file)
@@ -73,104 +49,6 @@ class Pry
         raise klass, message
       end
 
-      def make_header(meth, content=meth.source)
-        header = "\n#{Pry::Helpers::Text.bold('From:')} #{meth.source_file} "
-
-        if meth.source_type == :c
-          header << "(C Method):\n"
-        else
-          header << "@ line #{meth.source_line}:\n"
-        end
-
-        header << "#{Pry::Helpers::Text.bold("Number of lines:")} #{content.each_line.count.to_s}\n"
-      end
-
-      def invoke_editor(file, line, reloading)
-        raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless Pry.config.editor
-        if Pry.config.editor.respond_to?(:call)
-          args = [file, line, reloading][0...(Pry.config.editor.arity)]
-          editor_invocation = Pry.config.editor.call(*args)
-        else
-          editor_invocation = "#{Pry.config.editor} #{blocking_flag_for_editor(reloading)} #{start_line_syntax_for_editor(file, line)}"
-        end
-        return nil unless editor_invocation
-
-        if jruby?
-          begin
-            require 'spoon'
-            pid = Spoon.spawnp(*editor_invocation.split)
-            Process.waitpid(pid)
-          rescue FFI::NotFoundError
-            system(editor_invocation)
-          end
-        else
-          # 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(editor_invocation) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
-        end
-      end
-
-      # Some editors that run outside the terminal allow you to control whether or
-      # not to block the process from which they were launched (in this case, Pry).
-      # For those editors, return the flag that produces the desired behavior.
-      def blocking_flag_for_editor(block)
-        case editor_name
-        when /^emacsclient/
-          '--no-wait' unless block
-        when /^[gm]vim/
-          '--nofork' if block
-        when /^jedit/
-          '-wait' if block
-        when /^mate/, /^subl/
-          '-w' if block
-        end
-      end
-
-      # Return the syntax for a given editor for starting the editor
-      # and moving to a particular line within that file
-      def start_line_syntax_for_editor(file_name, line_number)
-        if windows?
-          file_name = file_name.gsub(/\//, '\\')
-        end
-
-        # special case for 1st line
-        return file_name if line_number <= 1
-
-        case editor_name
-        when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-          "+#{line_number} #{file_name}"
-        when /^mate/, /^geany/
-          "-l #{line_number} #{file_name}"
-        when /^subl/
-          "#{file_name}:#{line_number}"
-        when /^uedit32/
-          "#{file_name}/#{line_number}"
-        when /^jedit/
-          "#{file_name} +line:#{line_number}"
-        else
-          if windows?
-            "#{file_name}"
-          else
-            "+#{line_number} #{file_name}"
-          end
-        end
-      end
-
-      # Get the name of the binary that Pry.config.editor points to.
-      #
-      # This is useful for deciding which flags we pass to the editor as
-      # we can just use the program's name and ignore any absolute paths.
-      #
-      # @example
-      #   Pry.config.editor="/home/conrad/bin/textmate -w"
-      #   editor_name
-      #   # => textmate
-      #
-      def editor_name
-        File.basename(Pry.config.editor).split(" ").first
-      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
@@ -193,12 +71,14 @@ class Pry
       #
       # @param [String] text The text from which to remove indentation
       # @return [String] The text with indentation stripped.
-      def unindent(text)
+      def unindent(text, left_padding = 0)
         # Empty blank lines
         text = text.sub(/^[ \t]+$/, '')
 
         # Find the longest common whitespace to all indented lines
-        margin = text.scan(/^[ \t]*(?=[^ \t\n])/).inject do |current_margin, next_indent|
+        # 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|
           if next_indent.start_with?(current_margin)
             current_margin
           elsif current_margin.start_with?(next_indent)
@@ -208,7 +88,7 @@ class Pry
           end
         end
 
-        text.gsub(/^#{margin}/, '')
+        text.gsub(/^#{margin}/, ' ' * left_padding)
       end
 
       # Restrict a string to the given range of lines (1-indexed)
@@ -261,6 +141,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)
+
+        _pry_.last_dir = File.dirname(_pry_.last_file)
+        _pry_.inject_local("_dir_", _pry_.last_dir, target)
+      end
     end
 
   end