pry 0.9.7.4-i386-mswin32 → 0.9.8-i386-mswin32

data/lib/pry/pry_instance.rb

@@ -1,4 +1,3 @@
-require "pry/command_processor.rb"
 require "pry/indent"
 
 class Pry
@@ -8,7 +7,6 @@ class Pry
   attr_accessor :commands
   attr_accessor :print
   attr_accessor :exception_handler
-  attr_accessor :hooks
   attr_accessor :input_stack
 
   attr_accessor :custom_completions
@@ -16,13 +14,32 @@ class Pry
   attr_accessor :binding_stack
 
   attr_accessor :last_result
-  attr_accessor :last_exception
   attr_accessor :last_file
   attr_accessor :last_dir
 
+  attr_reader :last_exception
+
   attr_reader :input_array
   attr_reader :output_array
 
+  attr_accessor :backtrace
+
+  # Special treatment for hooks as we want to alert people of the
+  # changed API
+  attr_reader :hooks
+
+  # FIXME:
+  # This is a hack to alert people of the new API.
+  # @param [Pry::Hooks] v Only accept `Pry::Hooks` now!
+  def hooks=(v)
+    if v.is_a?(Hash)
+      warn "Hash-based hooks are now deprecated! Use a `Pry::Hooks` object instead! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+      @hooks = Pry::Hooks.from_hash(v)
+    else
+      @hooks = v
+    end
+  end
+
   # Create a new `Pry` object.
   # @param [Hash] options The optional configuration parameters.
   # @option options [#readline] :input The object to use for input.
@@ -35,7 +52,6 @@ class Pry
   def initialize(options={})
     refresh(options)
 
-    @command_processor = CommandProcessor.new(self)
     @binding_stack     = []
     @indent            = Pry::Indent.new
   end
@@ -57,7 +73,7 @@ class Pry
     end
 
     defaults.merge!(options).each do |key, value|
-      send "#{key}=", value
+      send("#{key}=", value) if respond_to?("#{key}=")
     end
 
     true
@@ -106,21 +122,14 @@ 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)
     inject_local("_out_", @output_array, target)
     inject_local("_pry_", self, target)
-    inject_local("_ex_", nil, target)
-    inject_local("_file_", nil, target)
-    inject_local("_dir_", nil, target)
+    inject_local("_ex_", last_exception, target)
+    inject_local("_file_", last_file, target)
+    inject_local("_dir_", last_dir, target)
 
     # without this line we get 1 test failure, ask Mon_Ouie
     set_last_result(nil, target)
@@ -136,13 +145,13 @@ class Pry
 
   def special_locals
     {
-      :_in_ => @input_array,
-      :_out_ => @output_array,
-      :_pry_ => self,
-      :_ex_ => last_exception,
+      :_in_   => @input_array,
+      :_out_  => @output_array,
+      :_pry_  => self,
+      :_ex_   => last_exception,
       :_file_ => last_file,
-      :_dir_ => last_dir,
-      :_ => last_result
+      :_dir_  => last_dir,
+      :_      => last_result
     }
   end
 
@@ -188,8 +197,9 @@ class Pry
       end
     end
 
+    break_data || nil
+  ensure
     repl_epilogue(target)
-    break_data || target_self
   end
 
   # Perform a read-eval-print.
@@ -232,15 +242,16 @@ class Pry
 
     code = r(target)
 
-    result = set_last_result(target.eval(code, Pry.eval_path, Pry.current_line), target)
+    result = target.eval(code, Pry.eval_path, Pry.current_line)
+    set_last_result(result, target, code)
+
     result
-  rescue CommandError, Slop::InvalidOptionError => e
-    output.puts "Error: #{e.message}"
-    @suppress_output = true
   rescue RescuableException => e
-    set_last_exception(e, target)
+    self.last_exception = e
+    e
   ensure
     update_input_history(code)
+    exec_hook :after_eval, result, self
   end
 
   # Perform a read.
@@ -259,16 +270,24 @@ 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)
+      begin
+        break if complete_expression?(eval_string)
+      rescue SyntaxError => e
+        output.puts "SyntaxError: #{e.message.sub(/.*syntax error, */m, '')}"
+        eval_string = ""
+      end
     end
 
     @suppress_output = true if eval_string =~ /;\Z/ || eval_string.empty?
 
+    exec_hook :after_read, eval_string, self
     eval_string
   end
 
@@ -294,10 +313,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,45 +329,60 @@ 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)
+        output.flush
       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)
-    result = @command_processor.process_commands(val, eval_string, target)
+  # @return [Boolean] `true` if `val` is a command, `false` otherwise
+  def process_command(val, eval_string, target)
+    result = commands.process_line(val, {
+      :target => target,
+      :output => output,
+      :eval_string => eval_string,
+      :pry_instance => self
+    })
 
     # set a temporary (just so we can inject the value we want into eval_string)
     Thread.current[:__pry_cmd_result__] = result
@@ -351,16 +390,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
 
@@ -368,36 +407,63 @@ class Pry
   # @param [String] val The command (and its params) to execute.
   # @param [String] eval_string The current input buffer.
   # @param [Binding] target The binding to use..
-  # @return [Pry::CommandContext::VOID_VALUE]
+  # @return [Pry::Command::VOID_VALUE]
   # @example
   #   pry_instance.run_command("ls -m")
   def run_command(val, eval_string = "", target = binding_stack.last)
-    process_line(val, eval_string, target)
-    Pry::CommandContext::VOID_VALUE
+    commands.process_line(val,
+      :eval_string => eval_string,
+      :target => target,
+      :pry_instance => self,
+      :output => output
+    )
+    Pry::Command::VOID_VALUE
+  end
+
+  # Execute the specified hook.
+  # @param [Symbol] name The hook name to execute
+  # @param [*Object] args The arguments to pass to the hook
+  # @return [Object, Exception] The return value of the hook or the exception raised
+  #
+  # If executing a hook raises an exception, we log that and then continue sucessfully.
+  # To debug such errors, use the global variable $pry_hook_error, which is set as a
+  # result.
+  def exec_hook(name, *args, &block)
+    e_before = hooks.errors.size
+    hooks.exec_hook(name, *args, &block).tap do
+      hooks.errors[e_before..-1].each do |e|
+        output.puts "#{name} hook failed: #{e.class}: #{e.message}"
+        output.puts "#{e.backtrace.first}"
+        output.puts "(see _pry_.hooks.errors to debug)"
+      end
+    end
   end
 
   # Set the last result of an eval.
   # This method should not need to be invoked directly.
   # @param [Object] result The result.
   # @param [Binding] target The binding to set `_` on.
-  def set_last_result(result, target)
+  # @param [String] code The code that was run.
+  def set_last_result(result, target, code="")
     @last_result_is_exception = false
     @output_array << result
 
-    self.last_result = result
+    self.last_result = result unless code =~ /\A\s*\z/
   end
 
   # Set the last exception for a session.
-  # This method should not need to be invoked directly.
-  # @param [Exception] ex The exception.
-  # @param [Binding] target The binding to set `_ex_` on.
-  def set_last_exception(ex, target)
+  # @param [Exception] ex
+  def last_exception=(ex)
     class << ex
       attr_accessor :file, :line, :bt_index
       def bt_source_location_for(index)
         backtrace[index] =~ /(.*):(\d+)/
         [$1, $2.to_i]
       end
+
+      def inc_bt_index
+        @bt_index = (@bt_index + 1) % backtrace.size
+      end
     end
 
     ex.bt_index = 0
@@ -405,8 +471,7 @@ class Pry
 
     @last_result_is_exception = true
     @output_array << ex
-
-    self.last_exception = ex
+    @last_exception = ex
   end
 
   # Update Pry's internal state after evalling code.
@@ -480,14 +545,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 +594,49 @@ 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) do
+        Helpers::BaseHelpers.silence_warnings do
+          eval("BEGIN{throw :valid}\n#{str}", binding, Pry.eval_path)
+        end
+      end
     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 , is incomplete.
+    str !~ /[,]\z/
+  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