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

data/lib/pry/config/convenience.rb

@@ -0,0 +1,26 @@
+module Pry::Config::Convenience
+  SHORTCUTS = [
+               :input,
+               :output,
+               :commands,
+               :print,
+               :exception_handler,
+               :quiet?,
+               :hooks,
+               :color,
+               :pager,
+               :editor,
+               :memory_size,
+               :extra_sticky_locals
+              ]
+
+
+  def config_shortcut(*names)
+    names.each do |name|
+      reader = name
+      setter = "#{name}="
+      define_method(reader) { config.public_send(name) }
+      define_method(setter) { |value| config.public_send(setter, value) }
+    end
+  end
+end

data/lib/pry/config/default.rb

@@ -0,0 +1,165 @@
+class Pry::Config::Default
+  include Pry::Config::Behavior
+
+  default = {
+    input: proc {
+      lazy_readline
+    },
+    output: proc {
+      $stdout
+    },
+    commands: proc {
+      Pry::Commands
+    },
+    prompt_name: proc {
+      Pry::DEFAULT_PROMPT_NAME
+    },
+    prompt: proc {
+      Pry::DEFAULT_PROMPT
+    },
+    prompt_safe_objects: proc {
+      Pry::DEFAULT_PROMPT_SAFE_OBJECTS
+    },
+    print: proc {
+      Pry::DEFAULT_PRINT
+    },
+    quiet: proc {
+      false
+    },
+    exception_handler: proc {
+      Pry::DEFAULT_EXCEPTION_HANDLER
+    },
+    exception_whitelist: proc {
+      Pry::DEFAULT_EXCEPTION_WHITELIST
+    },
+    hooks: proc {
+      Pry::DEFAULT_HOOKS
+    },
+    pager: proc {
+      true
+    },
+    system: proc {
+      Pry::DEFAULT_SYSTEM
+    },
+    color: proc {
+      Pry::Helpers::BaseHelpers.use_ansi_codes?
+    },
+    default_window_size: proc {
+      5
+    },
+    editor: proc {
+      Pry.default_editor_for_platform
+    }, # TODO: Pry::Platform.editor
+    should_load_rc: proc {
+      true
+    },
+    should_load_local_rc: proc {
+      true
+    },
+    should_trap_interrupts: proc {
+      Pry::Helpers::BaseHelpers.jruby?
+    }, # TODO: Pry::Platform.jruby?
+    disable_auto_reload: proc {
+      false
+    },
+    command_prefix: proc {
+      ""
+    },
+    auto_indent: proc {
+      Pry::Helpers::BaseHelpers.use_ansi_codes?
+    },
+    correct_indent: proc {
+      true
+    },
+    collision_warning: proc {
+      false
+    },
+    output_prefix: proc {
+      "=> "
+    },
+    requires: proc {
+      []
+    },
+    should_load_requires: proc {
+      true
+    },
+    should_load_plugins: proc {
+      true
+    },
+    windows_console_warning: proc {
+      true
+    },
+    control_d_handler: proc {
+      Pry::DEFAULT_CONTROL_D_HANDLER
+    },
+    memory_size: proc {
+      100
+    },
+    extra_sticky_locals: proc {
+      {}
+    },
+    command_completions: proc {
+      proc { commands.keys }
+    },
+    file_completions: proc {
+      proc { Dir["."] }
+    },
+    ls: proc {
+      Pry::Config.from_hash(Pry::Command::Ls::DEFAULT_OPTIONS)
+    },
+    completer: proc {
+      require "pry/input_completer"
+      Pry::InputCompleter
+    }
+  }
+
+  def initialize
+    super(nil)
+    configure_gist
+    configure_history
+  end
+
+  def quiet?
+    quiet
+  end
+
+  default.each do |key, value|
+    define_method(key) do
+      if default[key].equal?(value)
+        default[key] = instance_eval(&value)
+      end
+      default[key]
+    end
+  end
+
+private
+  # TODO:
+  # all of this configure_* stuff is a relic of old code.
+  # we should try move this code to being command-local.
+  def configure_gist
+    self["gist"] = Pry::Config.from_hash(inspecter: proc(&:pretty_inspect))
+  end
+
+  def configure_history
+    self["history"] = Pry::Config.from_hash "should_save" => true,
+      "should_load" => true
+    history.file = File.expand_path("~/.pry_history") rescue nil
+    if history.file.nil?
+      self.should_load_rc = false
+      history.should_save = false
+      history.should_load = false
+    end
+  end
+
+  def lazy_readline
+    require 'readline'
+    Readline
+  rescue LoadError
+    warn "Sorry, you can't use Pry without Readline or a compatible library."
+    warn "Possible solutions:"
+    warn " * Rebuild Ruby with Readline support using `--with-readline`"
+    warn " * Use the rb-readline gem, which is a pure-Ruby port of Readline"
+    warn " * Use the pry-coolline gem, a pure-ruby alternative to Readline"
+    raise
+  end
+end

data/lib/pry/core_extensions.rb

@@ -1,3 +1,24 @@
+class Pry
+  # @return [Array] Code of the method used when implementing Pry's
+  #   __binding__, along with line indication to be used with instance_eval (and
+  #   friends).
+  #
+  # @see Object#__binding__
+  BINDING_METHOD_IMPL = [<<-METHOD, __FILE__, __LINE__ + 1]
+    # Get a binding with 'self' set to self, and no locals.
+    #
+    # The default definee is determined by the context in which the
+    # definition is eval'd.
+    #
+    # Please don't call this method directly, see {__binding__}.
+    #
+    # @return [Binding]
+    def __pry__
+      binding
+    end
+  METHOD
+end
+
 class Object
   # Start a Pry REPL on self.
   #
@@ -45,66 +66,66 @@ class Object
   #
   # @return [Binding]
   def __binding__
+    # If you ever feel like changing this method, be careful about variables
+    # that you use. They shouldn't be inserted into the binding that will
+    # eventually be returning.
+
     # When you're cd'd into a class, methods you define should be added to it.
     if is_a?(Module)
       # class_eval sets both self and the default definee to this class.
       return class_eval "binding"
     end
 
-    unless respond_to?(:__binding_impl__)
-      binding_impl_method = [<<-METHOD, __FILE__, __LINE__ + 1]
-        # Get a binding with 'self' set to self, and no locals.
-        #
-        # The default definee is determined by the context in which the
-        # definition is eval'd.
-        #
-        # Please don't call this method directly, see {__binding__}.
-        #
-        # @return [Binding]
-        def __binding_impl__
-          binding
-        end
-      METHOD
-
+    unless respond_to?(:__pry__)
       # The easiest way to check whether an object has a working singleton class
       # is to try and define a method on it. (just checking for the presence of
       # the singleton class gives false positives for `true` and `false`).
-      # __binding_impl__ is just the closest method we have to hand, and using
+      # __pry__ is just the closest method we have to hand, and using
       # it has the nice property that we can memoize this check.
       begin
         # instance_eval sets the default definee to the object's singleton class
-        instance_eval(*binding_impl_method)
+        instance_eval(*Pry::BINDING_METHOD_IMPL)
 
       # If we can't define methods on the Object's singleton_class. Then we fall
       # back to setting the default definee to be the Object's class. That seems
       # nicer than having a REPL in which you can't define methods.
-      rescue TypeError
+      rescue TypeError, Pry::FrozenObjectException
         # class_eval sets the default definee to self.class
-        self.class.class_eval(*binding_impl_method)
+        self.class.class_eval(*Pry::BINDING_METHOD_IMPL)
       end
     end
 
-    __binding_impl__
+    __pry__
   end
 end
 
-# There's a splat bug on jruby in 1.9 emulation mode, which breaks the
-# pp library.
-#
-# * http://jira.codehaus.org/browse/JRUBY-6687
-# * https://github.com/pry/pry/issues/568
-#
-# Until that gets fixed upstream, let's monkey-patch here:
-if [[1, 2]].pretty_inspect == "[1]\n"
-  class Array
-    def pretty_print(q)
-      q.group(1, '[', ']') {
-        i = 0
-        q.seplist(self) { |*|
-          q.pp self[i]
-          i += 1
-        }
-      }
-    end
+class BasicObject
+  # Return a binding object for the receiver.
+  #
+  # The `self` of the binding is set to the current object, and it contains no
+  # local variables.
+  #
+  # The default definee (http://yugui.jp/articles/846) is set such that new
+  # methods defined will be added to the singleton class of the BasicObject.
+  #
+  # @return [Binding]
+  def __binding__
+    # BasicObjects don't have respond_to?, so we just define the method
+    # every time. As they also don't have `.freeze`, this call won't
+    # fail as it can for normal Objects.
+    (class << self; self; end).class_eval <<-EOF, __FILE__, __LINE__ + 1
+      # Get a binding with 'self' set to self, and no locals.
+      #
+      # The default definee is determined by the context in which the
+      # definition is eval'd.
+      #
+      # Please don't call this method directly, see {__binding__}.
+      #
+      # @return [Binding]
+      def __pry__
+        ::Kernel.binding
+      end
+    EOF
+    self.__pry__
   end
 end

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