pry 0.9.7.4 → 0.9.8pre2

data/lib/pry/plugins.rb

@@ -32,13 +32,21 @@ class Pry
         self.enabled = true
       end
 
+      # Load the Command line options defined by this plugin (if they exist)
+      def load_cli_options
+        cli_options_file = File.join(spec.full_gem_path, "lib/#{spec.name}/cli.rb")
+        require cli_options_file if File.exists?(cli_options_file)
+      end
       # Activate the plugin (require the gem - enables/loads the
-      # plugin immediately at point of call, even if plugin is disabled)
+      # plugin immediately at point of call, even if plugin is
+      # disabled)
+      # Does not reload plugin if it's already active.
       def activate!
         begin
           require gem_name if !active?
-        rescue LoadError
+        rescue LoadError => e
           $stderr.puts "Warning: The plugin '#{gem_name}' was not found! (gem found but could not be loaded)"
+          $stderr.puts e
         end
         self.active = true
         self.enabled = true

data/lib/pry/pry_class.rb

@@ -73,6 +73,30 @@ class Pry
     end
   end
 
+  # Trap interrupts on jruby, and make them behave like MRI so we can
+  # catch them.
+  def self.load_traps
+    trap('INT'){ raise Interrupt }
+  end
+
+  # Do basic setup for initial session.
+  # Including: loading .pryrc, loading plugins, loading requires, and
+  # loading history.
+  def self.initial_session_setup
+
+    return if !initial_session?
+
+    # note these have to be loaded here rather than in pry_instance as
+    # we only want them loaded once per entire Pry lifetime.
+    load_rc if Pry.config.should_load_rc
+    load_plugins if Pry.config.plugins.enabled
+    load_requires if Pry.config.should_load_requires
+    load_history if Pry.config.history.should_load
+    load_traps if Pry.config.should_trap_interrupts
+
+    @initial_session = false
+  end
+
   # Start a Pry REPL.
   # This method also loads the files specified in `Pry::RC_FILES` the
   # first time it is invoked.
@@ -82,19 +106,23 @@ class Pry
   # @example
   #   Pry.start(Object.new, :input => MyInput.new)
   def self.start(target=TOPLEVEL_BINDING, options={})
-    if initial_session?
-      # note these have to be loaded here rather than in pry_instance as
-      # we only want them loaded once per entire Pry lifetime, not
-      # multiple times per each new session (i.e in debugging)
-      load_rc if Pry.config.should_load_rc
-      load_plugins if Pry.config.plugins.enabled
-      load_requires if Pry.config.should_load_requires
-      load_history if Pry.config.history.should_load
-
-      @initial_session = false
-    end
+    target = Pry.binding_for(target)
+    initial_session_setup
 
-    new(options).repl(target)
+    # create the Pry instance to manage the session
+    pry_instance = new(options)
+
+    # save backtrace
+    pry_instance.backtrace = caller.tap(&:shift)
+
+    # yield the binding_stack to the hook for modification
+    Pry.config.hooks.exec_hook(:when_started, binding_stack = [target], pry_instance)
+
+    head, *tail = binding_stack
+    pry_instance.binding_stack.push(*tail)
+
+    # Enter the matrix
+    pry_instance.repl(head)
   end
 
   # An inspector that clips the output to `max_length` chars.
@@ -120,17 +148,12 @@ class Pry
 
   # Load Readline history if required.
   def self.load_history
-    Pry.history.load(history_file) if File.exists?(history_file)
+    Pry.history.load
   end
 
   # Save new lines of Readline history if required.
   def self.save_history
-    Pry.history.save(history_file)
-  end
-
-  # Get the full path of the history_path for pry.
-  def self.history_file
-    File.expand_path(Pry.config.history.file)
+    Pry.history.save
   end
 
   # @return [Boolean] Whether this is the first time a Pry session has
@@ -165,7 +188,7 @@ class Pry
 
     output = options[:show_output] ? options[:output] : StringIO.new
 
-    Pry.new(:output => output, :input => StringIO.new(command_string), :commands => options[:commands], :prompt => proc {""}, :hooks => {}).rep(options[:context])
+    Pry.new(:output => output, :input => StringIO.new(command_string), :commands => options[:commands], :prompt => proc {""}, :hooks => Pry::Hooks.new).rep(options[:context])
   end
 
   def self.default_editor_for_platform
@@ -192,10 +215,15 @@ class Pry
     config.system = DEFAULT_SYSTEM
     config.editor = default_editor_for_platform
     config.should_load_rc = true
+    config.should_trap_interrupts = defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
     config.disable_auto_reload = false
     config.command_prefix = ""
     config.auto_indent = true
     config.correct_indent = true
+    config.collision_warning = false
+
+    config.gist ||= OpenStruct.new
+    config.gist.inspecter = proc &:pretty_inspect
 
     config.plugins ||= OpenStruct.new
     config.plugins.enabled = true

data/lib/pry/pry_instance.rb

@@ -23,6 +23,8 @@ class Pry
   attr_reader :input_array
   attr_reader :output_array
 
+  attr_accessor :backtrace
+
   # Create a new `Pry` object.
   # @param [Hash] options The optional configuration parameters.
   # @option options [#readline] :input The object to use for input.
@@ -106,13 +108,6 @@ class Pry
     @output_array = Pry::HistoryArray.new(size)
   end
 
-  # Execute the hook `hook_name`, if it is defined.
-  # @param [Symbol] hook_name The hook to execute
-  # @param [Array] args The arguments to pass to the hook.
-  def exec_hook(hook_name, *args, &block)
-    hooks[hook_name].call(*args, &block) if hooks[hook_name]
-  end
-
   # Make sure special locals exist at start of session
   def initialize_special_locals(target)
     inject_local("_in_", @input_array, target)
@@ -149,7 +144,7 @@ class Pry
   # Initialize the repl session.
   # @param [Binding] target The target binding for the session.
   def repl_prologue(target)
-    exec_hook :before_session, output, target, self
+    hooks.exec_hook :before_session, output, target, self
     initialize_special_locals(target)
 
     @input_array << nil # add empty input so _in_ and _out_ match
@@ -161,7 +156,7 @@ class Pry
   # Clean-up after the repl session.
   # @param [Binding] target The target binding for the session.
   def repl_epilogue(target)
-    exec_hook :after_session, output, target, self
+    hooks.exec_hook :after_session, output, target, self
 
     Pry.active_sessions -= 1
     binding_stack.pop
@@ -189,7 +184,7 @@ class Pry
     end
 
     repl_epilogue(target)
-    break_data || target_self
+    break_data || nil
   end
 
   # Perform a read-eval-print.
@@ -234,13 +229,11 @@ class Pry
 
     result = set_last_result(target.eval(code, Pry.eval_path, Pry.current_line), target)
     result
-  rescue CommandError, Slop::InvalidOptionError => e
-    output.puts "Error: #{e.message}"
-    @suppress_output = true
   rescue RescuableException => e
-    set_last_exception(e, target)
+    result = set_last_exception(e, target)
   ensure
     update_input_history(code)
+    hooks.exec_hook :after_eval, result, self
   end
 
   # Perform a read.
@@ -259,16 +252,19 @@ class Pry
 
     val = ""
     loop do
-      val = retrieve_line(eval_string, target)
-
-      # eval_string may be mutated by this method
-      process_line(val, eval_string, target)
+      begin
+        # eval_string will probably be mutated by this method
+        retrieve_line(eval_string, target)
+      rescue CommandError, Slop::InvalidOptionError => e
+        output.puts "Error: #{e.message}"
+      end
 
-      break if valid_expression?(eval_string)
+      break if complete_expression?(eval_string)
     end
 
     @suppress_output = true if eval_string =~ /;\Z/ || eval_string.empty?
 
+    hooks.exec_hook :after_read, eval_string, self
     eval_string
   end
 
@@ -294,10 +290,15 @@ class Pry
     end
   end
 
-  # Read a line of input and check for ^d, also determine prompt to use.
-  # This method should not need to be invoked directly. This method also
-  # automatically indents the input value using Pry::Indent if auto
-  # indenting is enabled.
+  def should_force_encoding?(eval_string, val)
+    eval_string.empty? && val.respond_to?(:encoding) && val.encoding != eval_string.encoding
+  end
+  private :should_force_encoding?
+
+  # Read and process a line of input -- check for ^D, determine which prompt to
+  # use, rewrite the indentation if `Pry.config.auto_indent` is enabled, and,
+  # if the line is a command, process it and alter the eval_string accordingly.
+  # This method should not need to be invoked directly.
   #
   # @param [String] eval_string The cumulative lines of input.
   # @param [Binding] target The target of the session.
@@ -305,44 +306,53 @@ class Pry
   def retrieve_line(eval_string, target)
     @indent.reset if eval_string.empty?
 
-    current_prompt = select_prompt(eval_string.empty?, target.eval('self'))
+    current_prompt = select_prompt(eval_string, target)
     indentation = Pry.config.auto_indent ? @indent.indent_level : ''
 
-    val = readline(current_prompt + indentation)
+    val = readline("#{current_prompt}#{indentation}")
 
     # invoke handler if we receive EOF character (^D)
     if !val
       output.puts ""
       Pry.config.control_d_handler.call(eval_string, self)
-      ""
-    else
-      # Change the eval_string into the input encoding (Issue 284)
-      # TODO: This wouldn't be necessary if the eval_string was constructed from
-      # input strings only.
-      if eval_string.empty? && val.respond_to?(:encoding) && val.encoding != eval_string.encoding
-        eval_string.force_encoding(val.encoding)
-      end
+      return
+    end
 
-      if !@command_processor.valid_command?(val, target) && Pry.config.auto_indent && !input.is_a?(StringIO)
-        orig_val = "#{indentation}#{val}"
-        val = @indent.indent(val)
+    # Change the eval_string into the input encoding (Issue 284)
+    # TODO: This wouldn't be necessary if the eval_string was constructed from
+    # input strings only.
+    if should_force_encoding?(eval_string, val)
+      eval_string.force_encoding(val.encoding)
+    end
 
-        if orig_val != val && output.tty? && Pry::Helpers::BaseHelpers.use_ansi_codes? && Pry.config.correct_indent
-          output.print @indent.correct_indentation(current_prompt + val, orig_val.length - val.length)
-        end
+    if Pry.config.auto_indent && !input.is_a?(StringIO)
+      original_val = "#{indentation}#{val}"
+      indented_val = @indent.indent(val)
+
+      if original_val != indented_val && output.tty? && Pry::Helpers::BaseHelpers.use_ansi_codes? && Pry.config.correct_indent
+        output.print @indent.correct_indentation(current_prompt + indented_val, original_val.length - indented_val.length)
       end
+    else
+      indented_val = val
+    end
 
-      Pry.history << val.dup unless input.is_a?(StringIO)
-      val
+    begin
+      if !process_command(val, eval_string, target)
+        eval_string << "#{indented_val.rstrip}\n" unless val.empty?
+      end
+    ensure
+      Pry.history << indented_val unless input.is_a?(StringIO)
     end
   end
 
-  # Process the line received.
+  # If the given line is a valid command, process it in the context of the
+  # current `eval_string` and context.
   # This method should not need to be invoked directly.
   # @param [String] val The line to process.
   # @param [String] eval_string The cumulative lines of input.
   # @param [Binding] target The target of the Pry session.
-  def process_line(val, eval_string, target)
+  # @return [Boolean] `true` if `val` is a command, `false` otherwise
+  def process_command(val, eval_string, target)
     result = @command_processor.process_commands(val, eval_string, target)
 
     # set a temporary (just so we can inject the value we want into eval_string)
@@ -351,16 +361,16 @@ class Pry
     # note that `result` wraps the result of command processing; if a
     # command was matched and invoked then `result.command?` returns true,
     # otherwise it returns false.
-    if result.command? && !result.void_command?
-
-      # the command that was invoked was non-void (had a return value) and so we make
-      # the value of the current expression equal to the return value
-      # of the command.
-      eval_string.replace "Thread.current[:__pry_cmd_result__].retval\n"
+    if result.command?
+      if !result.void_command?
+        # the command that was invoked was non-void (had a return value) and so we make
+        # the value of the current expression equal to the return value
+        # of the command.
+        eval_string.replace "Thread.current[:__pry_cmd_result__].retval\n"
+      end
+      true
     else
-      # only commands should have an empty `val`
-      # so this ignores their result
-      eval_string << "#{val.rstrip}\n" if !val.empty?
+      false
     end
   end
 
@@ -372,7 +382,7 @@ class Pry
   # @example
   #   pry_instance.run_command("ls -m")
   def run_command(val, eval_string = "", target = binding_stack.last)
-    process_line(val, eval_string, target)
+    @command_processor.process_commands(val, eval_string, target)
     Pry::CommandContext::VOID_VALUE
   end
 
@@ -480,14 +490,17 @@ class Pry
 
   # Returns the appropriate prompt to use.
   # This method should not need to be invoked directly.
-  # @param [Boolean] first_line Whether this is the first line of input
-  #   (and not multi-line input).
-  # @param [Object] target_self The receiver of the Pry session.
+  # @param [String] eval_string The current input buffer.
+  # @param [Binding] target The target Binding of the Pry session.
   # @return [String] The prompt.
-  def select_prompt(first_line, target_self)
+  def select_prompt(eval_string, target)
+    target_self = target.eval('self')
 
-    if first_line
+    # If input buffer is empty then use normal prompt
+    if eval_string.empty?
       Array(prompt).first.call(target_self, binding_stack.size - 1, self)
+
+    # Otherwise use the wait prompt (indicating multi-line expression)
     else
       Array(prompt).last.call(target_self, binding_stack.size - 1, self)
     end
@@ -526,45 +539,47 @@ class Pry
     prompt_stack.size > 1 ? prompt_stack.pop : prompt
   end
 
-  if RUBY_VERSION =~ /1.9/ && RUBY_ENGINE == "ruby"
-    require 'ripper'
-
-    # Determine if a string of code is a valid Ruby expression.
-    # Ruby 1.9 uses Ripper, Ruby 1.8 uses RubyParser.
-    # @param [String] code The code to validate.
-    # @return [Boolean] Whether or not the code is a valid Ruby expression.
-    # @example
-    #   valid_expression?("class Hello") #=> false
-    #   valid_expression?("class Hello; end") #=> true
-    def valid_expression?(code)
-      !!Ripper::SexpBuilder.new(code).parse
+  # Determine if a string of code is a complete Ruby expression.
+  # @param [String] code The code to validate.
+  # @return [Boolean] Whether or not the code is a complete Ruby expression.
+  # @raise [SyntaxError] Any SyntaxError that does not represent incompleteness.
+  # @example
+  #   complete_expression?("class Hello") #=> false
+  #   complete_expression?("class Hello; end") #=> true
+  def complete_expression?(str)
+    if defined?(Rubinius::Melbourne19) && RUBY_VERSION =~ /^1\.9/
+      Rubinius::Melbourne19.parse_string(str, Pry.eval_path)
+    elsif defined?(Rubinius::Melbourne)
+      Rubinius::Melbourne.parse_string(str, Pry.eval_path)
+    else
+      catch(:valid) {
+        eval("BEGIN{throw :valid}\n#{str}", binding, Pry.eval_path)
+      }
     end
 
-  elsif RUBY_VERSION =~ /1.9/ && RUBY_ENGINE == 'jruby'
-
-    # JRuby doesn't have Ripper, so use its native parser for 1.9 mode.
-    def valid_expression?(code)
-      JRuby.parse(code)
-      true
-    rescue SyntaxError
+    # Assert that a line which ends with a , or a \ is incomplete.
+    str !~ /[,\\]$/
+  rescue SyntaxError => e
+    if incomplete_user_input_exception?(e)
       false
+    else
+      raise e
     end
+  end
 
-  else
-    require 'ruby_parser'
-
-    # Determine if a string of code is a valid Ruby expression.
-    # Ruby 1.9 uses Ripper, Ruby 1.8 uses RubyParser.
-    # @param [String] code The code to validate.
-    # @return [Boolean] Whether or not the code is a valid Ruby expression.
-    # @example
-    #   valid_expression?("class Hello") #=> false
-    #   valid_expression?("class Hello; end") #=> true
-    def valid_expression?(code)
-      # NOTE: we're using .dup because RubyParser mutates the input
-      RubyParser.new.parse(code.dup)
+  # Check whether the exception indicates that the user should input more.
+  #
+  # @param [SyntaxError] the exception object that was raised.
+  # @param [Array<String>] The stack frame of the function that executed eval.
+  # @return [Boolean]
+  #
+  def incomplete_user_input_exception?(ex)
+    case ex.message
+    when /unexpected (\$end|end-of-file|END_OF_FILE)/, # mri, jruby, ironruby
+        /unterminated (quoted string|string|regexp) meets end of file/, # "quoted string" is ironruby
+        /missing 'end' for/, /: expecting '[})\]]'$/, /can't find string ".*" anywhere before EOF/, /expecting keyword_end/ # rbx
       true
-    rescue Racc::ParseError, SyntaxError
+    else
       false
     end
   end