pry 0.10.0.pre4-x64-mingw32

data/lib/pry/object_path.rb

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

@@ -0,0 +1,50 @@
+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/pager.rb

@@ -0,0 +1,234 @@
+require 'pry/terminal'
+
+# A pager is an `IO`-like object that accepts text and either prints it
+# immediately, prints it one page at a time, or streams it to an external
+# program to print one page at a time.
+class Pry::Pager
+  class StopPaging < StandardError
+  end
+
+  attr_reader :_pry_
+
+  def initialize(_pry_)
+    @_pry_ = _pry_
+  end
+
+  # Send the given text through the best available pager (if `Pry.config.pager` is
+  # enabled).
+  # If you want to send text through in chunks as you generate it, use `open` to
+  # get a writable object instead.
+  # @param [String] text A piece of text to run through a pager.
+  # @param [IO] output (`$stdout`) An object to send output to.
+  def page(text)
+    open do |pager|
+      pager << text
+    end
+  end
+
+  # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`).  All
+  # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`.
+  # @param [IO] output (`$stdout`) An object to send output to.
+  def open
+    pager = best_available
+    yield pager
+  rescue StopPaging
+  ensure
+    pager.close if pager
+  end
+
+  private
+
+  attr_reader :output
+  def enabled?; !!@enabled; end
+
+  # Return an instance of the "best" available pager class -- `SystemPager` if
+  # possible, `SimplePager` if `SystemPager` isn't available, and `NullPager`
+  # if the user has disabled paging. All pagers accept output with `#puts`,
+  # `#print`, `#write`, and `#<<`. You must call `#close` when you're done
+  # writing output to a pager, and you must rescue `Pry::Pager::StopPaging`.
+  # These requirements can be avoided by using `.open` instead.
+  # @param [#<<] output ($stdout) An object to send output to.
+  def best_available
+    if !_pry_.config.pager
+      NullPager.new(_pry_.output)
+    elsif !SystemPager.available? || Pry::Helpers::BaseHelpers.jruby?
+      SimplePager.new(_pry_.output)
+    else
+      SystemPager.new(_pry_.output)
+    end
+  end
+
+  # `NullPager` is a "pager" that actually just prints all output as it comes
+  # in. Used when `Pry.config.pager` is false.
+  class NullPager
+    def initialize(out)
+      @out = out
+    end
+
+    def puts(str)
+      print "#{str.chomp}\n"
+    end
+
+    def print(str)
+      write str
+    end
+    alias << print
+
+    def write(str)
+      @out.write str
+    end
+
+    def close
+    end
+
+    private
+
+    def height
+      @height ||= Pry::Terminal.height!
+    end
+
+    def width
+      @width ||= Pry::Terminal.width!
+    end
+  end
+
+  # `SimplePager` is a straightforward pure-Ruby pager. We use it on JRuby and
+  # when we can't find a usable external pager.
+  class SimplePager < NullPager
+    def initialize(*)
+      super
+      @tracker = PageTracker.new(height - 3, width)
+    end
+
+    def write(str)
+      str.lines.each do |line|
+        @out.print line
+        @tracker.record line
+
+        if @tracker.page?
+          @out.print "\n"
+          @out.print "\e[0m"
+          @out.print "<page break> --- Press enter to continue " \
+                     "( q<enter> to break ) --- <page break>\n"
+          raise StopPaging if Readline.readline("").chomp == "q"
+          @tracker.reset
+        end
+      end
+    end
+  end
+
+  # `SystemPager` buffers output until we're pretty sure it's at least a page
+  # long, then invokes an external pager and starts streaming output to it. If
+  # `#close` is called before then, it just prints out the buffered content.
+  class SystemPager < NullPager
+    def self.default_pager
+      pager = ENV["PAGER"] || ""
+
+      # Default to less, and make sure less is being passed the correct options
+      if pager.strip.empty? or pager =~ /^less\b/
+        pager = "less -R -F -X"
+      end
+
+      pager
+    end
+
+    def self.available?
+      if @system_pager.nil?
+        @system_pager = begin
+          pager_executable = default_pager.split(' ').first
+          `which #{ pager_executable }`
+        rescue
+          false
+        end
+      else
+        @system_pager
+      end
+    end
+
+    def initialize(*)
+      super
+      @tracker = PageTracker.new(height, width)
+      @buffer  = ""
+    end
+
+    def write(str)
+      if invoked_pager?
+        write_to_pager str
+      else
+        @tracker.record str
+        @buffer << str
+
+        if @tracker.page?
+          write_to_pager @buffer
+        end
+      end
+    rescue Errno::EPIPE
+      raise StopPaging
+    end
+
+    def close
+      if invoked_pager?
+        pager.close
+      else
+        @out.puts @buffer
+      end
+    end
+
+    private
+
+    def write_to_pager(text)
+      pager.write @out.decolorize_maybe(text)
+    end
+
+    def invoked_pager?
+      @pager
+    end
+
+    def pager
+      @pager ||= IO.popen(self.class.default_pager, 'w')
+    end
+  end
+
+  # `PageTracker` tracks output to determine whether it's likely to take up a
+  # whole page. This doesn't need to be super precise, but we can use it for
+  # `SimplePager` and to avoid invoking the system pager unnecessarily.
+  #
+  # One simplifying assumption is that we don't need `#page?` to return `true`
+  # on the basis of an incomplete line. Long lines should be counted as
+  # multiple lines, but we don't have to transition from `false` to `true`
+  # until we see a newline.
+  class PageTracker
+    def initialize(rows, cols)
+      @rows, @cols = rows, cols
+      reset
+    end
+
+    def record(str)
+      str.lines.each do |line|
+        if line.end_with? "\n"
+          @row += ((@col + line_length(line) - 1) / @cols) + 1
+          @col  = 0
+        else
+          @col += line_length(line)
+        end
+      end
+    end
+
+    def page?
+      @row >= @rows
+    end
+
+    def reset
+      @row = 0
+      @col = 0
+    end
+
+    private
+
+    # Approximation of the printable length of a given line, without the
+    # newline and without ANSI color codes.
+    def line_length(line)
+      line.chomp.gsub(/\e\[[\d;]*m/, '').length
+    end
+  end
+end

data/lib/pry/plugins.rb

@@ -0,0 +1,103 @@
+class Pry
+  class PluginManager
+    PRY_PLUGIN_PREFIX = /^pry-/
+
+    # Placeholder when no associated gem found, displays warning
+    class NoPlugin
+      def initialize(name)
+        @name = name
+      end
+
+      def method_missing(*args)
+        warn "Warning: The plugin '#{@name}' was not found! (no gem found)"
+      end
+    end
+
+    class Plugin
+      attr_accessor :name, :gem_name, :enabled, :spec, :active
+
+      def initialize(name, gem_name, spec, enabled)
+        @name, @gem_name, @enabled, @spec = name, gem_name, enabled, spec
+      end
+
+      # Disable a plugin. (prevents plugin from being loaded, cannot
+      # disable an already activated plugin)
+      def disable!
+        self.enabled = false
+      end
+
+      # Enable a plugin. (does not load it immediately but puts on
+      # 'white list' to be loaded)
+      def enable!
+        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)
+      # Does not reload plugin if it's already active.
+      def activate!
+        # Create the configuration object for the plugin.
+        Pry.config.send("#{gem_name.gsub('-', '_')}=", Pry::Config.from_hash({}))
+
+        begin
+          require gem_name if !active?
+        rescue LoadError => e
+          warn "Found plugin #{gem_name}, but could not require '#{gem_name}'"
+          warn e
+        rescue => e
+          warn "require '#{gem_name}' # Failed, saying: #{e}"
+        end
+
+        self.active = true
+        self.enabled = true
+      end
+
+      alias active? active
+      alias enabled? enabled
+    end
+
+    def initialize
+      @plugins = []
+    end
+
+    # Find all installed Pry plugins and store them in an internal array.
+    def locate_plugins
+      Gem.refresh
+      (Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')).each do |gem|
+        next if gem.name !~ PRY_PLUGIN_PREFIX
+        plugin_name = gem.name.split('-', 2).last
+        @plugins << Plugin.new(plugin_name, gem.name, gem, true) if !gem_located?(gem.name)
+      end
+      @plugins
+    end
+
+    # @return [Hash] A hash with all plugin names (minus the 'pry-') as
+    #   keys and Plugin objects as values.
+    def plugins
+      h = Hash.new { |_, key| NoPlugin.new(key) }
+      @plugins.each do |plugin|
+        h[plugin.name] = plugin
+      end
+      h
+    end
+
+    # Require all enabled plugins, disabled plugins are skipped.
+    def load_plugins
+      @plugins.each do |plugin|
+        plugin.activate! if plugin.enabled?
+      end
+    end
+
+    private
+    def gem_located?(gem_name)
+      @plugins.any? { |plugin| plugin.gem_name == gem_name }
+    end
+  end
+
+end