pry 0.10.0.pre4-x64-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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,113 @@
+class Pry
+  module Helpers
+
+    module BaseHelpers
+
+      module_function
+
+      def silence_warnings
+        old_verbose = $VERBOSE
+        $VERBOSE = nil
+        begin
+          yield
+        ensure
+          $VERBOSE = old_verbose
+        end
+      end
+
+      # 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)
+        file =~ /(\(.*\))|<.*>/ || file =~ /__unknown__/ || file == "" || file == "-e"
+      end
+
+      def command_dependencies_met?(options)
+        return true if !options[:requires_gem]
+        Array(options[:requires_gem]).all? do |g|
+          Rubygem.installed?(g)
+        end
+      end
+
+      def use_ansi_codes?
+        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
+      end
+
+      def colorize_code(code)
+        CodeRay.scan(code, :ruby).term
+      end
+
+      def highlight(string, regexp, highlight_color=:bright_yellow)
+        string.gsub(regexp) { |match| "<#{highlight_color}>#{match}</#{highlight_color}>" }
+      end
+
+      # formatting
+      def heading(text)
+        text = "#{text}\n--"
+        "\e[1m#{text}\e[0m"
+      end
+
+      # have fun on the Windows platform.
+      def windows?
+        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+      end
+
+      # are we able to use ansi on windows?
+      def windows_ansi?
+        defined?(Win32::Console) || ENV['ANSICON'] || (windows? && mri_2?)
+      end
+
+      def jruby?
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
+      end
+
+      def jruby_19?
+        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
+      end
+
+      def rbx?
+        RbConfig::CONFIG['ruby_install_name'] == 'rbx'
+      end
+
+      def mri?
+        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
+      def mri_19?
+        mri? && RUBY_VERSION =~ /^1\.9/
+      end
+
+      def mri_2?
+        mri? && RUBY_VERSION =~ /^2/
+      end
+
+      def mri_20?
+        mri? && RUBY_VERSION =~ /^2\.0/
+      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

@@ -0,0 +1,156 @@
+class Pry
+  module Helpers
+
+    module CommandHelpers
+      include OptionsHelpers
+
+      module_function
+
+      # Open a temp file and yield it to the block, closing it after
+      # @return [String] The path of the temp file
+      def temp_file(ext='.rb')
+        file = Tempfile.new(['pry', ext])
+        yield file
+      ensure
+        file.close(true) if file
+      end
+
+      def internal_binding?(target)
+        m = target.eval("::Kernel.__method__").to_s
+        # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
+        ["__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, 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, MethodNotFound)
+          end
+        end
+
+        if !meth || (!name && internal_binding?(target))
+          command_error("No method name given, and context is not a method.", omit_help, MethodNotFound)
+        end
+
+        set_file_and_dir_locals(meth.source_file)
+        meth
+      end
+
+      def command_error(message, omit_help, klass=CommandError)
+        message += " Type `#{command_name} --help` for help." unless omit_help
+        raise klass, message
+      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
+      # sacrificing the indentation level of the source code.
+      #
+      # e.g.
+      #   opt.banner unindent <<-USAGE
+      #     Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+      #     sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+      #       "Ut enim ad minim veniam."
+      #   USAGE
+      #
+      # Heavily based on textwrap.dedent from Python, which is:
+      #   Copyright (C) 1999-2001 Gregory P. Ward.
+      #   Copyright (C) 2002, 2003 Python Software Foundation.
+      #   Written by Greg Ward <gward@python.net>
+      #
+      #   Licensed under <http://docs.python.org/license.html>
+      #   From <http://hg.python.org/cpython/file/6b9f0a6efaeb/Lib/textwrap.py>
+      #
+      # @param [String] text The text from which to remove indentation
+      # @return [String] The text with indentation stripped.
+      def unindent(text, left_padding = 0)
+        # Empty blank lines
+        text = text.sub(/^[ \t]+$/, '')
+
+        # Find the longest common whitespace to all indented lines
+        # 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)
+            next_indent
+          else
+            ""
+          end
+        end
+
+        text.gsub(/^#{margin}/, ' ' * left_padding)
+      end
+
+      # Restrict a string to the given range of lines (1-indexed)
+      # @param [String] content The string.
+      # @param [Range, Fixnum] lines The line(s) to restrict it to.
+      # @return [String] The resulting string.
+      def restrict_to_lines(content, lines)
+        line_range = one_index_range_or_number(lines)
+        Array(content.lines.to_a[line_range]).join
+      end
+
+      def one_index_number(line_number)
+        if line_number > 0
+          line_number - 1
+        else
+          line_number
+        end
+      end
+
+      # convert a 1-index range to a 0-indexed one
+      def one_index_range(range)
+        Range.new(one_index_number(range.begin), one_index_number(range.end))
+      end
+
+      def one_index_range_or_number(range_or_number)
+        case range_or_number
+        when Range
+          one_index_range(range_or_number)
+        else
+          one_index_number(range_or_number)
+        end
+      end
+
+      def absolute_index_number(line_number, array_length)
+        if line_number >= 0
+          line_number
+        else
+          [array_length + line_number, 0].max
+        end
+      end
+
+      def absolute_index_range(range_or_number, array_length)
+        case range_or_number
+        when Range
+          a = absolute_index_number(range_or_number.begin, array_length)
+          b = absolute_index_number(range_or_number.end, array_length)
+        else
+          a = b = absolute_index_number(range_or_number, array_length)
+        end
+
+        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
+end