pry 0.10.2-i386-mswin32 → 1.0.0.pre1-i386-mswin32

data/lib/pry/input_lock.rb

@@ -1,132 +0,0 @@
-require 'thread'
-
-class Pry
-  # There is one InputLock per input (such as STDIN) as two REPLs on the same
-  # input makes things delirious. InputLock serializes accesses to the input so
-  # that threads to not conflict with each other. The latest thread to request
-  # ownership of the input wins.
-  class InputLock
-    class Interrupt < Exception; end
-
-    class << self
-      attr_accessor :input_locks
-      attr_accessor :global_lock
-    end
-
-    self.input_locks = {}
-    self.global_lock = Mutex.new
-
-    def self.for(input)
-      # XXX This method leaks memory, as we never unregister an input once we
-      # are done with it. Fortunately, the leak is tiny (or so we hope).  In
-      # usual scenarios, we would leak the StringIO that is passed to be
-      # evaluated from the command line.
-      global_lock.synchronize do
-        input_locks[input] ||= Pry::InputLock.new
-      end
-    end
-
-    def initialize
-      @mutex = Mutex.new
-      @cond = ConditionVariable.new
-      @owners = []
-      @interruptible = false
-    end
-
-    # Adds ourselves to the ownership list. The last one in the list may access
-    # the input through interruptible_region().
-    def __with_ownership(&block)
-      @mutex.synchronize do
-        # Three cases:
-        # 1) There are no owners, in this case we are good to go.
-        # 2) The current owner of the input is not reading the input (it might
-        #    just be evaluating some ruby that the user typed).
-        #    The current owner will figure out that it cannot go back to reading
-        #    the input since we are adding ourselves to the @owners list, which
-        #    in turns makes us the current owner.
-        # 3) The owner of the input is in the interruptible region, reading from
-        #    the input. It's safe to send an Interrupt exception to interrupt
-        #    the owner. It will then proceed like in case 2).
-        #    We wait until the owner sets the interruptible flag back
-        #    to false, meaning that he's out of the interruptible region.
-        #    Note that the owner may receive multiple interrupts since, but that
-        #    should be okay (and trying to avoid it is futile anyway).
-        while @interruptible
-          @owners.last.raise Interrupt
-          @cond.wait(@mutex)
-        end
-        @owners << Thread.current
-      end
-
-      block.call
-
-    ensure
-      @mutex.synchronize do
-        # We are releasing any desire to have the input ownership by removing
-        # ourselves from the list.
-        @owners.delete(Thread.current)
-
-        # We need to wake up the thread at the end of the @owners list, but
-        # sadly Ruby doesn't allow us to choose which one we wake up, so we wake
-        # them all up.
-        @cond.broadcast
-      end
-    end
-
-    def with_ownership(&block)
-      # If we are in a nested with_ownership() call (nested pry context), we do nothing.
-      nested = @mutex.synchronize { @owners.include?(Thread.current) }
-      nested ? block.call : __with_ownership(&block)
-    end
-
-    def enter_interruptible_region
-      @mutex.synchronize do
-        # We patiently wait until we are the owner. This may happen as another
-        # thread calls with_ownership() because of a binding.pry happening in
-        # another thread.
-        @cond.wait(@mutex) until @owners.last == Thread.current
-
-        # We are the legitimate owner of the input. We mark ourselves as
-        # interruptible, so other threads can send us an Interrupt exception
-        # while we are blocking from reading the input.
-        @interruptible = true
-      end
-    end
-
-    def leave_interruptible_region
-      @mutex.synchronize do
-        # We check if we are still the owner, because we could have received an
-        # Interrupt right after the following @cond.broadcast, making us retry.
-        @interruptible = false if @owners.last == Thread.current
-        @cond.broadcast
-      end
-    rescue Interrupt
-      # We need to guard against a spurious interrupt delivered while we are
-      # trying to acquire the lock (the rescue block is no longer in our scope).
-      retry
-    end
-
-    def interruptible_region(&block)
-      enter_interruptible_region
-
-      # XXX Note that there is a chance that we get the interrupt right after
-      # the readline call succeeded, but we'll never know, and we will retry the
-      # call, discarding that piece of input.
-      block.call
-
-    rescue Interrupt
-      # We were asked to back off. The one requesting the interrupt will be
-      # waiting on the conditional for the interruptible flag to change to false.
-      # Note that there can be some inefficiency, as we could immediately
-      # succeed in enter_interruptible_region(), even before the one requesting
-      # the ownership has the chance to register itself as an owner.
-      # To mitigate the issue, we sleep a little bit.
-      leave_interruptible_region
-      sleep 0.01
-      retry
-
-    ensure
-      leave_interruptible_region
-    end
-  end
-end

data/lib/pry/inspector.rb

@@ -1,27 +0,0 @@
-class Pry::Inspector
-  MAP = {
-    "default" => {
-      value: Pry::DEFAULT_PRINT,
-      description: <<-DESCRIPTION.each_line.map(&:lstrip!)
-        The default Pry inspector. It has paging and color support, and uses
-        pretty_inspect when printing an object.
-      DESCRIPTION
-    },
-
-    "simple" => {
-      value: Pry::SIMPLE_PRINT,
-      description: <<-DESCRIPTION.each_line.map(&:lstrip)
-        A simple inspector that uses #puts and #inspect when printing an
-        object. It has no pager, color, or pretty_inspect support.
-      DESCRIPTION
-    },
-
-    "clipped" => {
-      value: Pry::CLIPPED_PRINT,
-      description: <<-DESCRIPTION.each_line.map(&:lstrip)
-        The clipped inspector has the same features as the 'simple' inspector
-        but prints large objects as a smaller string.
-      DESCRIPTION
-    }
-  }
-end

data/lib/pry/last_exception.rb

@@ -1,61 +0,0 @@
-#
-# {Pry::LastException} is a proxy class who wraps an Exception object for
-# {Pry#last_exception}. it extends the exception object with methods that
-# help pry commands be useful.
-#
-# the original exception object is not modified and method calls are forwarded
-# to the wrapped exception object.
-#
-class Pry::LastException < BasicObject
-  attr_accessor :bt_index
-
-  def initialize(e)
-    @e = e
-    @bt_index = 0
-    @file, @line = bt_source_location_for(0)
-  end
-
-  def method_missing(name, *args, &block)
-    if @e.respond_to?(name)
-      @e.public_send(name, *args, &block)
-    else
-      super
-    end
-  end
-
-  def respond_to_missing?(name, include_private = false)
-    @e.respond_to?(name)
-  end
-
-  #
-  # @return [String]
-  #  returns the path to a file for the current backtrace. see {#bt_index}.
-  #
-  def file
-    @file
-  end
-
-  #
-  # @return [Fixnum]
-  #  returns the line for the current backtrace. see {#bt_index}.
-  #
-  def line
-    @line
-  end
-
-  # @return [Exception]
-  #   returns the wrapped exception
-  #
-  def wrapped_exception
-    @e
-  end
-
-  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

data/lib/pry/object_path.rb

@@ -1,82 +0,0 @@
-class Pry
-  # `ObjectPath` implements the resolution of "object paths", which are strings
-  # that are similar to filesystem paths but meant for traversing Ruby objects.
-  # Examples of valid object paths include:
-  #
-  #     x
-  #     @foo/@bar
-  #     "string"/upcase
-  #     Pry/Method
-  #
-  # Object paths are mostly relevant in the context of the `cd` command.
-  # @see https://github.com/pry/pry/wiki/State-navigation
-  class ObjectPath
-    SPECIAL_TERMS = ["", "::", ".", ".."]
-
-    # @param [String] path_string The object path expressed as a string.
-    # @param [Array<Binding>] current_stack The current state of the binding
-    #   stack.
-    def initialize(path_string, current_stack)
-      @path_string   = path_string
-      @current_stack = current_stack
-    end
-
-    # @return [Array<Binding>] a new stack resulting from applying the given
-    #   path to the current stack.
-    def resolve
-      scanner = StringScanner.new(@path_string.strip)
-      stack   = @current_stack.dup
-
-      begin
-        next_segment  = ""
-
-        loop do
-          # Scan for as long as we don't see a slash
-          next_segment << scanner.scan(/[^\/]*/)
-
-          if complete?(next_segment) || scanner.eos?
-            scanner.getch # consume the slash
-            break
-          else
-            next_segment << scanner.getch # append the slash
-          end
-        end
-
-        case next_segment.chomp
-        when ""
-          stack = [stack.first]
-        when "::"
-          stack.push(TOPLEVEL_BINDING)
-        when "."
-          next
-        when ".."
-          stack.pop unless stack.size == 1
-        else
-          stack.push(Pry.binding_for(stack.last.eval(next_segment)))
-        end
-      rescue RescuableException => e
-        return handle_failure(next_segment, e)
-      end until scanner.eos?
-
-      stack
-    end
-
-    private
-
-    def complete?(segment)
-      SPECIAL_TERMS.include?(segment) || Pry::Code.complete_expression?(segment)
-    end
-
-    def handle_failure(context, err)
-      msg = [
-        "Bad object path: #{@path_string.inspect}",
-        "Failed trying to resolve: #{context.inspect}",
-        "Exception: #{err.inspect}"
-      ].join("\n")
-
-      raise CommandError.new(msg).tap { |e|
-        e.set_backtrace err.backtrace
-      }
-    end
-  end
-end

data/lib/pry/output.rb

@@ -1,50 +0,0 @@
-class Pry
-  class Output
-    attr_reader :_pry_
-
-    def initialize(_pry_)
-      @_pry_ = _pry_
-    end
-
-    def puts(*objs)
-      return print "\n" if objs.empty?
-
-      objs.each do |obj|
-        if ary = Array.try_convert(obj)
-          puts(*ary)
-        else
-          print "#{obj.to_s.chomp}\n"
-        end
-      end
-
-      nil
-    end
-
-    def print(*objs)
-      objs.each do |obj|
-        _pry_.config.output.print decolorize_maybe(obj.to_s)
-      end
-
-      nil
-    end
-    alias << print
-    alias write print
-
-    # If _pry_.config.color is currently false, removes ansi escapes from the string.
-    def decolorize_maybe(str)
-      if _pry_.config.color
-        str
-      else
-        Helpers::Text.strip_color str
-      end
-    end
-
-    def method_missing(name, *args, &block)
-      _pry_.config.output.send(name, *args, &block)
-    end
-
-    def respond_to_missing?(*a)
-      _pry_.config.respond_to?(*a)
-    end
-  end
-end

data/lib/pry/prompt.rb

@@ -1,26 +0,0 @@
-class Pry::Prompt
-  MAP = {
-    "default" => {
-      value: Pry::DEFAULT_PROMPT,
-      description: "The default Pry prompt. Includes information about the\n" \
-                   "current expression number, evaluation context, and nesting\n" \
-                   "level, plus a reminder that you're using Pry."
-    },
-
-    "simple" => {
-      value: Pry::SIMPLE_PROMPT,
-      description: "A simple '>>'."
-    },
-
-    "nav" => {
-      value: Pry::NAV_PROMPT,
-      description: "A prompt that displays the binding stack as a path and\n" \
-                   "includes information about _in_ and _out_."
-    },
-
-    "none" => {
-      value: Pry::NO_PROMPT,
-      description: "Wave goodbye to the Pry prompt."
-    }
- }
-end