sshp 0.0.1

data/vendor/ruby/1.9.1/gems/pry-0.9.12.2/lib/pry/rbx_method.rb

@@ -0,0 +1,13 @@
+class Pry
+  module RbxMethod
+    private
+
+    def core_code
+      MethodSource.source_helper(source_location)
+    end
+
+    def core_doc
+      MethodSource.comment_helper(source_location)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/pry-0.9.12.2/lib/pry/rbx_path.rb

@@ -0,0 +1,22 @@
+class Pry
+  module RbxPath
+    module_function
+    def is_core_path?(path)
+      path.start_with?("kernel") || path.start_with?("lib")
+    end
+
+    def convert_path_to_full(path)
+      if path.start_with?("kernel")
+        File.join File.dirname(Rubinius::KERNEL_PATH), path
+      elsif path.start_with?("lib")
+        File.join File.dirname(Rubinius::LIB_PATH), path
+      else
+        path
+      end
+    end
+
+    def rvm_ruby?(path)
+      !!(path =~ /\.rvm/)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/pry-0.9.12.2/lib/pry/repl_file_loader.rb

@@ -0,0 +1,80 @@
+class Pry
+
+  # A class to manage the loading of files through the REPL loop.
+  # This is an interesting trick as it processes your file as if it
+  # was user input in an interactive session. As a result, all Pry
+  # commands are available, and they are executed non-interactively. Furthermore
+  # the session becomes interactive when the repl loop processes a
+  # 'make-interactive' command in the file. The session also becomes
+  # interactive when an exception is encountered, enabling you to fix
+  # the error before returning to non-interactive processing with the
+  # 'make-non-interactive' command.
+
+  class REPLFileLoader
+    def initialize(file_name)
+      full_name = File.expand_path(file_name)
+      raise RuntimeError, "No such file: #{full_name}" if !File.exists?(full_name)
+
+      @content = StringIO.new(File.read(full_name))
+    end
+
+    # Switch to interactive mode, i.e take input from the user
+    # and use the regular print and exception handlers.
+    # @param [Pry] _pry_ the Pry instance to make interactive.
+    def interactive_mode(_pry_)
+      _pry_.input = Pry.config.input
+      _pry_.print = Pry.config.print
+      _pry_.exception_handler = Pry.config.exception_handler
+    end
+
+    # Switch to non-interactive mode. Essentially
+    # this means there is no result output
+    # and that the session becomes interactive when an exception is encountered.
+    # @param [Pry] _pry_ the Pry instance to make non-interactive.
+    def non_interactive_mode(_pry_)
+      _pry_.print = proc {}
+      _pry_.exception_handler = proc do |o, e, _pry_|
+        _pry_.run_command "cat --ex"
+        o.puts "...exception encountered, going interactive!"
+        interactive_mode(_pry_)
+      end
+    end
+
+    # Define a few extra commands useful for flipping back & forth
+    # between interactive/non-interactive modes
+    def define_additional_commands
+      s = self
+
+      Pry::Commands.command "make-interactive", "Make the session interactive" do
+        _pry_.input_stack.push _pry_.input
+        s.interactive_mode(_pry_)
+      end
+
+      Pry::Commands.command "make-non-interactive", "Make the session non-interactive" do
+        _pry_.input = _pry_.input_stack.pop
+        s.non_interactive_mode(_pry_)
+      end
+
+      Pry::Commands.command "load-file", "Load another file through the repl" do |file_name|
+        content = StringIO.new(File.read(File.expand_path(file_name)))
+        _pry_.input_stack.push(_pry_.input)
+        _pry_.input = content
+      end
+    end
+
+    # Actually load the file through the REPL by setting file content
+    # as the REPL input stream.
+    def load
+      Pry.initial_session_setup
+      define_additional_commands
+
+      Pry.config.hooks.add_hook(:when_started, :start_non_interactively) do |o, t, _pry_|
+        non_interactive_mode(_pry_)
+      end
+
+      Pry.start(Pry.toplevel_binding,
+                :input => @content,
+                :input_stack => [StringIO.new("exit-all\n")])
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/pry-0.9.12.2/lib/pry/rubygem.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+
+class Pry
+  module Rubygem
+
+    class << self
+      def installed?(name)
+        if Gem::Specification.respond_to?(:find_all_by_name)
+          Gem::Specification.find_all_by_name(name).any?
+        else
+          Gem.source_index.find_name(name).first
+        end
+      end
+
+      # Get the gem spec object for the given gem name.
+      #
+      # @param [String] name
+      # @return [Gem::Specification]
+      def spec(name)
+        specs = if Gem::Specification.respond_to?(:each)
+                  Gem::Specification.find_all_by_name(name)
+                else
+                  Gem.source_index.find_name(name)
+                end
+
+        spec = specs.sort_by{ |spec| Gem::Version.new(spec.version) }.first
+
+        spec or raise CommandError, "Gem `#{name}` not found"
+      end
+
+      # List gems matching a pattern.
+      #
+      # @param [Regexp] pattern
+      # @return [Array<Gem::Specification>]
+      def list(pattern = /.*/)
+        if Gem::Specification.respond_to?(:each)
+          Gem::Specification.select{|spec| spec.name =~ pattern }
+        else
+          Gem.source_index.gems.values.select{|spec| spec.name =~ pattern }
+        end
+      end
+
+      # Completion function for gem-cd and gem-open.
+      #
+      # @param [String] so_far what the user's typed so far
+      # @return [Array<String>] completions
+      def complete(so_far)
+        if so_far =~ / ([^ ]*)\z/
+          self.list(%r{\A#{$2}}).map(&:name)
+        else
+          self.list.map(&:name)
+        end
+      end
+
+      # Installs a gem with all its dependencies.
+      #
+      # @param [String] name
+      # @return [void]
+      def install(name)
+        destination = File.writable?(Gem.dir) ? Gem.dir : Gem.user_dir
+        installer = Gem::DependencyInstaller.new(:install_dir => destination)
+        installer.install(name)
+      rescue Errno::EACCES
+        raise CommandError,
+          "Insufficient permissions to install `#{ text.green(name) }`."
+      rescue Gem::GemNotFoundException
+        raise CommandError, "Gem `#{ text.green(name) }` not found."
+      else
+        Gem.refresh
+      end
+    end
+
+  end
+end

data/vendor/ruby/1.9.1/gems/pry-0.9.12.2/lib/pry/terminal.rb

@@ -0,0 +1,78 @@
+class Pry::Terminal
+  class << self
+    # Return a pair of [rows, columns] which gives the size of the window.
+    #
+    # If the window size cannot be determined, return nil.
+    def screen_size
+      rows, cols = actual_screen_size
+      if rows && cols
+        [rows.to_i, cols.to_i]
+      else
+        nil
+      end
+    end
+
+    # Return a screen size or a default if that fails.
+    def size! default = [27, 80]
+      screen_size || default
+    end
+
+    # Return a screen width or the default if that fails.
+    def width!
+      size![1]
+    end
+
+    # Return a screen height or the default if that fails.
+    def height!
+      size![0]
+    end
+
+    def actual_screen_size
+      # The best way, if possible (requires non-jruby ≥1.9 or io-console gem)
+      screen_size_according_to_io_console or
+        # Fall back to the old standby, though it might be stale:
+        screen_size_according_to_env or
+        # Fall further back, though this one is also out of date without something
+        # calling Readline.set_screen_size
+        screen_size_according_to_readline or
+        # Windows users can otherwise run ansicon and get a decent answer:
+        screen_size_according_to_ansicon_env
+    end
+
+    def screen_size_according_to_io_console
+      return if Pry::Helpers::BaseHelpers.jruby?
+      require 'io/console'
+      $stdout.winsize if $stdout.tty? and $stdout.respond_to?(:winsize)
+    rescue LoadError
+      # They're probably on 1.8 without the io-console gem. We'll keep trying.
+    end
+
+    def screen_size_according_to_env
+      size = [ENV['LINES'] || ENV['ROWS'], ENV['COLUMNS']]
+      size if nonzero_column?(size)
+    end
+
+    def screen_size_according_to_readline
+      if Readline.respond_to?(:get_screen_size)
+        size = Readline.get_screen_size
+        size if nonzero_column?(size)
+      end
+    rescue Java::JavaLang::NullPointerException
+      # This rescue won't happen on jrubies later than:
+      #     https://github.com/jruby/jruby/pull/436
+      nil
+    end
+
+    def screen_size_according_to_ansicon_env
+      return unless ENV['ANSICON'] =~ /\((.*)x(.*)\)/
+      size = [$2, $1]
+      size if nonzero_column?(size)
+    end
+
+    private
+
+    def nonzero_column?(size)
+      size[1].to_i > 0
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/pry-0.9.12.2/lib/pry/test/helper.rb

@@ -0,0 +1,185 @@
+require 'pry'
+
+# in case the tests call reset_defaults, ensure we reset them to
+# amended (test friendly) values
+class << Pry
+  alias_method :orig_reset_defaults, :reset_defaults
+  def reset_defaults
+    orig_reset_defaults
+
+    Pry.color = false
+    Pry.pager = false
+    Pry.config.should_load_rc      = false
+    Pry.config.should_load_local_rc= false
+    Pry.config.should_load_plugins = false
+    Pry.config.history.should_load = false
+    Pry.config.history.should_save = false
+    Pry.config.auto_indent         = false
+    Pry.config.hooks               = Pry::Hooks.new
+    Pry.config.collision_warning   = false
+  end
+end
+Pry.reset_defaults
+
+# A global space for storing temporary state during tests.
+
+module PryTestHelpers
+
+  module_function
+
+  # inject a variable into a binding
+  def inject_var(name, value, b)
+    Pry.current[:pry_local] = value
+    b.eval("#{name} = ::Pry.current[:pry_local]")
+  ensure
+    Pry.current[:pry_local] = nil
+  end
+
+  def constant_scope(*names)
+    names.each do |name|
+      Object.remove_const name if Object.const_defined?(name)
+    end
+
+    yield
+  ensure
+    names.each do |name|
+      Object.remove_const name if Object.const_defined?(name)
+    end
+  end
+
+  def mri18_and_no_real_source_location?
+    Pry::Helpers::BaseHelpers.mri_18? && !(Method.instance_method(:source_location).owner == Method)
+  end
+
+  # Open a temp file and yield it to the block, closing it after
+  # @return [String] The path of the temp file
+  def temp_file(ext='.rb')
+    file = Tempfile.new(['pry', ext])
+    yield file
+  ensure
+    file.close(true) if file
+    File.unlink("#{file.path}c") if File.exists?("#{file.path}c") # rbx
+  end
+
+  def unindent(*args)
+    Pry::Helpers::CommandHelpers.unindent(*args)
+  end
+
+  def mock_command(cmd, args=[], opts={})
+    output = StringIO.new
+    ret = cmd.new(opts.merge(:output => output)).call_safely(*args)
+    Struct.new(:output, :return).new(output.string, ret)
+  end
+
+  def mock_exception(*mock_backtrace)
+    e = StandardError.new("mock exception")
+    (class << e; self; end).class_eval do
+      define_method(:backtrace) { mock_backtrace }
+    end
+    e
+  end
+end
+
+def pry_tester(*args, &block)
+  if args.length == 0 || args[0].is_a?(Hash)
+    args.unshift(Pry.toplevel_binding)
+  end
+
+  PryTester.new(*args).tap do |t|
+    (class << t; self; end).class_eval(&block) if block
+  end
+end
+
+def pry_eval(*eval_strs)
+  if eval_strs.first.is_a? String
+    binding = Pry.toplevel_binding
+  else
+    binding = Pry.binding_for(eval_strs.shift)
+  end
+
+  pry_tester(binding).eval(*eval_strs)
+end
+
+class PryTester
+  attr_reader :pry, :out
+
+  def initialize(context = TOPLEVEL_BINDING, options = {})
+    @pry = Pry.new(options)
+
+    if context
+      target = Pry.binding_for(context)
+      @pry.binding_stack << target
+      @pry.inject_sticky_locals(target)
+    end
+
+    @pry.input_array << nil # TODO: shouldn't need this
+    reset_output
+  end
+
+  def eval(*strs)
+    reset_output
+    result = nil
+
+    strs.flatten.each do |str|
+      str = "#{str.strip}\n"
+      if @pry.process_command(str)
+        result = last_command_result_or_output
+      else
+        result = @pry.evaluate_ruby(str)
+      end
+    end
+
+    result
+  end
+
+  def context=(context)
+    @pry.binding_stack << Pry.binding_for(context)
+  end
+
+  # TODO: eliminate duplication with Pry#repl
+  def simulate_repl
+    didnt_exit = nil
+    break_data = nil
+
+    didnt_exit = catch(:didnt_exit) do
+      break_data = catch(:breakout) do
+        yield self
+        throw(:didnt_exit, true)
+      end
+      nil
+    end
+
+    raise "Failed to exit REPL" if didnt_exit
+    break_data
+  end
+
+  def last_output
+    @out.string if @out
+  end
+
+  def process_command(command_str, eval_str = '')
+    @pry.process_command(command_str, eval_str) or raise "Not a valid command"
+    last_command_result_or_output
+  end
+
+  protected
+
+  def last_command_result
+    result = Pry.current[:pry_cmd_result]
+    result.retval if result
+  end
+
+  def last_command_result_or_output
+    result = last_command_result
+    if result != Pry::Command::VOID_VALUE
+      result
+    else
+      last_output
+    end
+  end
+
+  def reset_output
+    @out = StringIO.new
+    @pry.output = @out
+  end
+end