pry 0.10.pre.1-i386-mingw32 → 0.10.0.pre3-i386-mingw32

data/lib/pry/editor.rb

@@ -0,0 +1,133 @@
+class Pry
+  class Editor
+    include Pry::Helpers::BaseHelpers
+    include Pry::Helpers::CommandHelpers
+
+    attr_reader :_pry_
+
+    def initialize(_pry_)
+      @_pry_ = _pry_
+    end
+
+    def edit_tempfile_with_content(initial_content, line=1)
+      temp_file do |f|
+        f.puts(initial_content)
+        f.flush
+        f.close(false)
+        invoke_editor(f.path, line, true)
+        File.read(f.path)
+      end
+    end
+
+    def invoke_editor(file, line, blocking=true)
+      raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless _pry_.config.editor
+
+      editor_invocation = build_editor_invocation_string(file, line, blocking)
+      return nil unless editor_invocation
+
+      if jruby?
+        open_editor_on_jruby(editor_invocation)
+      else
+        open_editor(editor_invocation)
+      end
+    end
+
+    private
+
+    # Generate the string that's used to start the editor. This includes
+    # all the flags we want as well as the file and line number we
+    # want to open at.
+    def build_editor_invocation_string(file, line, blocking)
+
+      if _pry_.config.editor.respond_to?(:call)
+        args = [file, line, blocking][0...(_pry_.config.editor.arity)]
+        _pry_.config.editor.call(*args)
+      else
+        sanitized_file = if windows?
+                            file.gsub(/\//, '\\')
+                          else
+                            Shellwords.escape(file)
+                          end
+
+        "#{_pry_.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
+      end
+    end
+
+    # Start the editor running, using the calculated invocation string
+    def open_editor(editor_invocation)
+      # 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(*Shellwords.split(editor_invocation)) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
+    end
+
+    # We need JRuby specific code here cos just shelling out using
+    # system() appears to be pretty broken :/
+    def open_editor_on_jruby(editor_invocation)
+      begin
+        require 'spoon'
+        pid = Spoon.spawnp(*Shellwords.split(editor_invocation))
+        Process.waitpid(pid)
+      rescue FFI::NotFoundError
+        system(editor_invocation)
+      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(blocking)
+      case editor_name
+      when /^emacsclient/
+        '--no-wait' unless blocking
+      when /^[gm]vim/
+        '--nofork' if blocking
+      when /^jedit/
+        '-wait' if blocking
+      when /^mate/, /^subl/
+        '-w' if blocking
+      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)
+      # 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
+
+  end
+end

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