sshp 0.0.1

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

@@ -0,0 +1,5 @@
+require "pry/helpers/base_helpers"
+require "pry/helpers/options_helpers"
+require "pry/helpers/command_helpers"
+require "pry/helpers/text"
+require "pry/helpers/table"

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

@@ -0,0 +1,200 @@
+class Pry
+  module Helpers
+
+    module BaseHelpers
+
+      module_function
+
+      def silence_warnings
+        old_verbose = $VERBOSE
+        $VERBOSE = nil
+        begin
+          yield
+        ensure
+          $VERBOSE = old_verbose
+        end
+      end
+
+      # Acts like send but ignores any methods defined below Object or Class in the
+      # inheritance hierarchy.
+      # This is required to introspect methods on objects like Net::HTTP::Get that
+      # have overridden the `method` method.
+      def safe_send(obj, method, *args, &block)
+        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
+      end
+      public :safe_send
+
+      def find_command(name, set = Pry::Commands)
+        command_match = set.find do |_, command|
+          (listing = command.options[:listing]) == name && listing != nil
+        end
+        command_match.last if command_match
+      end
+
+      def not_a_real_file?(file)
+        file =~ /(\(.*\))|<.*>/ || file =~ /__unknown__/ || file == "" || file == "-e"
+      end
+
+      def command_dependencies_met?(options)
+        return true if !options[:requires_gem]
+        Array(options[:requires_gem]).all? do |g|
+          Rubygem.installed?(g)
+        end
+      end
+
+      def set_file_and_dir_locals(file_name, _pry_=_pry_(), target=target())
+        return if !target or !file_name
+        _pry_.last_file = File.expand_path(file_name)
+        _pry_.inject_local("_file_", _pry_.last_file, target)
+
+        _pry_.last_dir = File.dirname(_pry_.last_file)
+        _pry_.inject_local("_dir_", _pry_.last_dir, target)
+      end
+
+      def use_ansi_codes?
+        windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
+      end
+
+      def colorize_code(code)
+        if Pry.color
+          CodeRay.scan(code, :ruby).term
+        else
+          code
+        end
+      end
+
+      def highlight(string, regexp, highlight_color=:bright_yellow)
+        string.gsub(regexp) { |match| "<#{highlight_color}>#{match}</#{highlight_color}>" }
+      end
+
+      # formatting
+      def heading(text)
+        text = "#{text}\n--"
+        Pry.color ? "\e[1m#{text}\e[0m": text
+      end
+
+      # have fun on the Windows platform.
+      def windows?
+        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+      end
+
+      # are we able to use ansi on windows?
+      def windows_ansi?
+        defined?(Win32::Console) || ENV['ANSICON']
+      end
+
+      def jruby?
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
+      end
+
+      def jruby_19?
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby' &&
+          RbConfig::CONFIG['ruby_version'] == '1.9'
+      end
+
+      def rbx?
+        RbConfig::CONFIG['ruby_install_name'] == 'rbx'
+      end
+
+      def mri_18?
+        RUBY_VERSION =~ /1.8/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
+      def mri_19?
+        RUBY_VERSION =~ /1.9/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
+      # Try to use `less` for paging, if it fails then use
+      # simple_pager. Also do not page if Pry.pager is falsey
+      def stagger_output(text, out = nil)
+        out ||= case
+                when respond_to?(:output)
+                  # Mixin.
+                  output
+                when Pry.respond_to?(:output)
+                  # Parent.
+                  Pry.output
+                else
+                  # Sys.
+                  $stdout
+                end
+
+        if text.lines.count < Pry::Pager.page_size || !Pry.pager
+          out.puts text
+        else
+          Pry::Pager.page(text)
+        end
+      rescue Errno::ENOENT
+        Pry::Pager.page(text, :simple)
+      rescue Errno::EPIPE
+      end
+
+      # @param [String] arg_string The object path expressed as a string.
+      # @param [Pry] _pry_ The relevant Pry instance.
+      # @param [Array<Binding>] old_stack The state of the old binding stack
+      # @return [Array<Array<Binding>, Array<Binding>>] An array
+      #   containing two elements: The new `binding_stack` and the old `binding_stack`.
+      def context_from_object_path(arg_string, _pry_=nil, old_stack=[])
+
+        # Extract command arguments. Delete blank arguments like " ", but
+        # don't delete empty strings like "".
+        path      = arg_string.split(/\//).delete_if { |a| a =~ /\A\s+\z/ }
+        stack     = _pry_.binding_stack.dup
+        state_old_stack = old_stack
+
+        # Special case when we only get a single "/", return to root.
+        if path.empty?
+          state_old_stack = stack.dup unless old_stack.empty?
+          stack = [stack.first]
+        end
+
+        path.each_with_index do |context, i|
+          begin
+            case context.chomp
+            when ""
+              state_old_stack = stack.dup
+              stack = [stack.first]
+            when "::"
+              state_old_stack = stack.dup
+              stack.push(TOPLEVEL_BINDING)
+            when "."
+              next
+            when ".."
+              unless stack.size == 1
+                # Don't rewrite old_stack if we're in complex expression
+                # (e.g.: `cd 1/2/3/../4).
+                state_old_stack = stack.dup if path.first == ".."
+                stack.pop
+              end
+            when "-"
+              unless old_stack.empty?
+                # Interchange current stack and old stack with each other.
+                stack, state_old_stack = state_old_stack, stack
+              end
+            else
+              state_old_stack = stack.dup if i == 0
+              stack.push(Pry.binding_for(stack.last.eval(context)))
+            end
+
+          rescue RescuableException => e
+            # Restore old stack to its initial values.
+            state_old_stack = old_stack
+
+            msg = [
+              "Bad object path: #{arg_string}.",
+              "Failed trying to resolve: #{context}.",
+              e.inspect
+            ].join(' ')
+
+            CommandError.new(msg).tap do |err|
+              err.set_backtrace e.backtrace
+              raise err
+            end
+          end
+        end
+        return stack, state_old_stack
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+class Pry
+  module Helpers
+
+    module CommandHelpers
+      include OptionsHelpers
+
+      module_function
+
+      # 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
+      end
+
+      def render_output(str, opts={})
+        if opts[:flood]
+          output.puts str
+        else
+          stagger_output str
+        end
+      end
+
+      def internal_binding?(target)
+        m = target.eval("::Kernel.__method__").to_s
+        # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
+        ["__binding__", "__pry__", "class_eval"].include?(m)
+      end
+
+      def get_method_or_raise(name, target, opts={}, omit_help=false)
+        meth = Pry::Method.from_str(name, target, opts)
+
+        if name && !meth
+          command_error("The method '#{name}' could not be found.", omit_help, MethodNotFound)
+        end
+
+        (opts[:super] || 0).times do
+          if meth.super
+            meth = meth.super
+          else
+            command_error("'#{meth.name_with_owner}' has no super method.", omit_help, MethodNotFound)
+          end
+        end
+
+        if !meth || (!name && internal_binding?(target))
+          command_error("No method name given, and context is not a method.", omit_help, MethodNotFound)
+        end
+
+        set_file_and_dir_locals(meth.source_file)
+        meth
+      end
+
+      def command_error(message, omit_help, klass=CommandError)
+        message += " Type `#{command_name} --help` for help." unless omit_help
+        raise klass, message
+      end
+
+      # Remove any common leading whitespace from every line in `text`.
+      #
+      # This can be used to make a HEREDOC line up with the left margin, without
+      # sacrificing the indentation level of the source code.
+      #
+      # e.g.
+      #   opt.banner unindent <<-USAGE
+      #     Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+      #     sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+      #       "Ut enim ad minim veniam."
+      #   USAGE
+      #
+      # Heavily based on textwrap.dedent from Python, which is:
+      #   Copyright (C) 1999-2001 Gregory P. Ward.
+      #   Copyright (C) 2002, 2003 Python Software Foundation.
+      #   Written by Greg Ward <gward@python.net>
+      #
+      #   Licensed under <http://docs.python.org/license.html>
+      #   From <http://hg.python.org/cpython/file/6b9f0a6efaeb/Lib/textwrap.py>
+      #
+      # @param [String] text The text from which to remove indentation
+      # @return [String] The text with indentation stripped.
+      def unindent(text, left_padding = 0)
+        # Empty blank lines
+        text = text.sub(/^[ \t]+$/, '')
+
+        # Find the longest common whitespace to all indented lines
+        # Ignore lines containing just -- or ++ as these seem to be used by
+        # comment authors as delimeters.
+        margin = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/).inject do |current_margin, next_indent|
+          if next_indent.start_with?(current_margin)
+            current_margin
+          elsif current_margin.start_with?(next_indent)
+            next_indent
+          else
+            ""
+          end
+        end
+
+        text.gsub(/^#{margin}/, ' ' * left_padding)
+      end
+
+      # Restrict a string to the given range of lines (1-indexed)
+      # @param [String] content The string.
+      # @param [Range, Fixnum] lines The line(s) to restrict it to.
+      # @return [String] The resulting string.
+      def restrict_to_lines(content, lines)
+        line_range = one_index_range_or_number(lines)
+        Array(content.lines.to_a[line_range]).join
+      end
+
+      def one_index_number(line_number)
+        if line_number > 0
+          line_number - 1
+        else
+          line_number
+        end
+      end
+
+      # convert a 1-index range to a 0-indexed one
+      def one_index_range(range)
+        Range.new(one_index_number(range.begin), one_index_number(range.end))
+      end
+
+      def one_index_range_or_number(range_or_number)
+        case range_or_number
+        when Range
+          one_index_range(range_or_number)
+        else
+          one_index_number(range_or_number)
+        end
+      end
+
+      def absolute_index_number(line_number, array_length)
+        if line_number >= 0
+          line_number
+        else
+          [array_length + line_number, 0].max
+        end
+      end
+
+      def absolute_index_range(range_or_number, array_length)
+        case range_or_number
+        when Range
+          a = absolute_index_number(range_or_number.begin, array_length)
+          b = absolute_index_number(range_or_number.end, array_length)
+        else
+          a = b = absolute_index_number(range_or_number, array_length)
+        end
+
+        Range.new(a, b)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+class Pry
+  module Helpers
+
+    # This class contains methods useful for extracting
+    # documentation from methods and classes.
+    module DocumentationHelpers
+
+      module_function
+
+      def process_rdoc(comment)
+        return comment unless Pry.color
+        comment = comment.dup
+        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
+          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/\B\+(\w+?)\+\B/)  { "\e[32m#{$1}\e[0m" }.
+          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { CodeRay.scan($1, :ruby).term }.
+          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }
+      end
+
+      def process_yardoc_tag(comment, tag)
+        in_tag_block = nil
+        comment.lines.map do |v|
+          if in_tag_block && v !~ /^\S/
+            Pry::Helpers::Text.strip_color Pry::Helpers::Text.strip_color(v)
+          elsif in_tag_block
+            in_tag_block = false
+            v
+          else
+            in_tag_block = true if v =~ /^@#{tag}/
+            v
+          end
+        end.join
+      end
+
+      def process_yardoc(comment)
+        yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
+                     "deprecate", "example", "raise"]
+        (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
+          gsub(/^@(#{yard_tags.join("|")})/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
+      end
+
+      def process_comment_markup(comment)
+        process_yardoc process_rdoc(comment)
+      end
+
+      # @param [String] code
+      # @return [String]
+      def strip_comments_from_c_code(code)
+        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
+      end
+
+      # Given a string that makes up a comment in a source-code file parse out the content
+      # that the user is intended to read. (i.e. without leading indentation, #-characters
+      # or shebangs)
+      #
+      # @param [String] comment
+      # @return [String]
+      def get_comment_content(comment)
+        comment = comment.dup
+        # Remove #!/usr/bin/ruby
+        comment.gsub!(/\A\#!.*$/, '')
+        # Remove leading empty comment lines
+        comment.gsub!(/\A\#+?$/, '')
+        comment.gsub!(/^\s*#/, '')
+        strip_leading_whitespace(comment)
+      end
+
+      # @param [String] text
+      # @return [String]
+      def strip_leading_whitespace(text)
+        Pry::Helpers::CommandHelpers.unindent(text)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+class Pry
+  module Helpers
+    module OptionsHelpers
+      module_function
+
+      # Add method options to the Slop instance
+      def method_options(opt)
+        @method_target = target
+        opt.on :M, "instance-methods", "Operate on instance methods."
+        opt.on :m, :methods, "Operate on methods."
+        opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors.", :as => :count
+        opt.on :c, :context, "Select object context to run under.", :argument => true do |context|
+          @method_target = Pry.binding_for(target.eval(context))
+        end
+      end
+
+      # Get the method object parsed by the slop instance
+      def method_object
+        @method_object ||= get_method_or_raise(args.empty? ? nil : args.join(" "), @method_target,
+                            :super => opts[:super],
+                            :instance => opts.present?(:'instance-methods') && !opts.present?(:'methods'),
+                            :methods  => opts.present?(:'methods') && !opts.present?(:'instance-methods')
+                           )
+      end
+    end
+  end
+end