geminfo 0.1.0 → 0.1.1

data/path/gems/pry-0.10.1-x86-mingw32/lib/pry/rbx_path.rb

@@ -1,22 +0,0 @@
-class Pry
-  module RbxPath
-    module_function
-    def is_core_path?(path)
-      Pry::Helpers::BaseHelpers.rbx? && (path.start_with?("kernel") || path.start_with?("lib")) && File.exist?(convert_path_to_full(path))
-    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/path/gems/pry-0.10.1-x86-mingw32/lib/pry/repl.rb

@@ -1,202 +0,0 @@
-require 'forwardable'
-
-class Pry
-  class REPL
-    extend Forwardable
-    def_delegators :@pry, :input, :output
-
-    # @return [Pry] The instance of {Pry} that the user is controlling.
-    attr_accessor :pry
-
-    # Instantiate a new {Pry} instance with the given options, then start a
-    # {REPL} instance wrapping it.
-    # @option options See {Pry#initialize}
-    def self.start(options)
-      new(Pry.new(options)).start
-    end
-
-    # Create an instance of {REPL} wrapping the given {Pry}.
-    # @param [Pry] pry The instance of {Pry} that this {REPL} will control.
-    # @param [Hash] options Options for this {REPL} instance.
-    # @option options [Object] :target The initial target of the session.
-    def initialize(pry, options = {})
-      @pry    = pry
-      @indent = Pry::Indent.new
-
-      if options[:target]
-        @pry.push_binding options[:target]
-      end
-    end
-
-    # Start the read-eval-print loop.
-    # @return [Object?] If the session throws `:breakout`, return the value
-    #   thrown with it.
-    # @raise [Exception] If the session throws `:raise_up`, raise the exception
-    #   thrown with it.
-    def start
-      prologue
-      Pry::InputLock.for(:all).with_ownership { repl }
-    ensure
-      epilogue
-    end
-
-    private
-
-    # Set up the repl session.
-    # @return [void]
-    def prologue
-      pry.exec_hook :before_session, pry.output, pry.current_binding, pry
-
-      # Clear the line before starting Pry. This fixes issue #566.
-      if pry.config.correct_indent
-        Kernel.print Pry::Helpers::BaseHelpers.windows_ansi? ? "\e[0F" : "\e[0G"
-      end
-    end
-
-    # The actual read-eval-print loop.
-    #
-    # The {REPL} instance is responsible for reading and looping, whereas the
-    # {Pry} instance is responsible for evaluating user input and printing
-    # return values and command output.
-    #
-    # @return [Object?] If the session throws `:breakout`, return the value
-    #   thrown with it.
-    # @raise [Exception] If the session throws `:raise_up`, raise the exception
-    #   thrown with it.
-    def repl
-      loop do
-        case val = read
-        when :control_c
-          output.puts ""
-          pry.reset_eval_string
-        when :no_more_input
-          output.puts "" if output.tty?
-          break
-        else
-          output.puts "" if val.nil? && output.tty?
-          return pry.exit_value unless pry.eval(val)
-        end
-      end
-    end
-
-    # Clean up after the repl session.
-    # @return [void]
-    def epilogue
-      pry.exec_hook :after_session, pry.output, pry.current_binding, pry
-    end
-
-    # Read a line of input from the user.
-    # @return [String] The line entered by the user.
-    # @return [nil] On `<Ctrl-D>`.
-    # @return [:control_c] On `<Ctrl+C>`.
-    # @return [:no_more_input] On EOF.
-    def read
-      @indent.reset if pry.eval_string.empty?
-      current_prompt = pry.select_prompt
-      indentation = pry.config.auto_indent ? @indent.current_prefix : ''
-
-      val = read_line("#{current_prompt}#{indentation}")
-
-      # Return nil for EOF, :no_more_input for error, or :control_c for <Ctrl-C>
-      return val unless String === val
-
-      if pry.config.auto_indent
-        original_val = "#{indentation}#{val}"
-        indented_val = @indent.indent(val)
-
-        if output.tty? && pry.config.correct_indent && Pry::Helpers::BaseHelpers.use_ansi_codes?
-          output.print @indent.correct_indentation(
-            current_prompt, indented_val,
-            original_val.length - indented_val.length
-          )
-          output.flush
-        end
-      else
-        indented_val = val
-      end
-
-      indented_val
-    end
-
-    # Manage switching of input objects on encountering `EOFError`s.
-    # @return [Object] Whatever the given block returns.
-    # @return [:no_more_input] Indicates that no more input can be read.
-    def handle_read_errors
-      should_retry = true
-      exception_count = 0
-
-      begin
-        yield
-      rescue EOFError
-        pry.config.input = Pry.config.input
-        if !should_retry
-          output.puts "Error: Pry ran out of things to read from! " \
-            "Attempting to break out of REPL."
-          return :no_more_input
-        end
-        should_retry = false
-        retry
-
-      # Handle <Ctrl+C> like Bash: empty the current input buffer, but don't
-      # quit.  This is only for MRI 1.9; other versions of Ruby don't let you
-      # send Interrupt from within Readline.
-      rescue Interrupt
-        return :control_c
-
-      # If we get a random error when trying to read a line we don't want to
-      # automatically retry, as the user will see a lot of error messages
-      # scroll past and be unable to do anything about it.
-      rescue RescuableException => e
-        puts "Error: #{e.message}"
-        output.puts e.backtrace
-        exception_count += 1
-        if exception_count < 5
-          retry
-        end
-        puts "FATAL: Pry failed to get user input using `#{input}`."
-        puts "To fix this you may be able to pass input and output file " \
-          "descriptors to pry directly. e.g."
-        puts "  Pry.config.input = STDIN"
-        puts "  Pry.config.output = STDOUT"
-        puts "  binding.pry"
-        return :no_more_input
-      end
-    end
-
-    # Returns the next line of input to be sent to the {Pry} instance.
-    # @param [String] current_prompt The prompt to use for input.
-    # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
-    def read_line(current_prompt)
-      handle_read_errors do
-        if defined? Coolline and input.is_a? Coolline
-          input.completion_proc = proc do |cool|
-            completions = @pry.complete cool.completed_word
-            completions.compact
-          end
-        elsif input.respond_to? :completion_proc=
-          input.completion_proc = proc do |input|
-            @pry.complete input
-          end
-        end
-
-        if defined?(Readline) and input == Readline
-          input_readline(current_prompt, false) # false since we'll add it manually
-        elsif defined? Coolline and input.is_a? Coolline
-          input_readline(current_prompt)
-        else
-          if input.method(:readline).arity == 1
-            input_readline(current_prompt)
-          else
-            input_readline
-          end
-        end
-      end
-    end
-
-    def input_readline(*args)
-      Pry::InputLock.for(:all).interruptible_region do
-        input.readline(*args)
-      end
-    end
-  end
-end

data/path/gems/pry-0.10.1-x86-mingw32/lib/pry/repl_file_loader.rb

@@ -1,74 +0,0 @@
-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)
-
-      define_additional_commands
-      @content = 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_.config.input = Pry.config.input
-      _pry_.config.print = Pry.config.print
-      _pry_.config.exception_handler = Pry.config.exception_handler
-      Pry::REPL.new(_pry_).start
-    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_, content)
-      _pry_.print = proc {}
-      _pry_.exception_handler = proc do |o, e, _p_|
-        _p_.run_command "cat --ex"
-        o.puts "...exception encountered, going interactive!"
-        interactive_mode(_pry_)
-      end
-
-      content.lines.each do |line|
-        break unless _pry_.eval line, :generated => true
-      end
-
-      unless _pry_.eval_string.empty?
-        _pry_.output.puts "#{_pry_.eval_string}...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
-        s.interactive_mode(_pry_)
-      end
-
-      Pry::Commands.command "load-file", "Load another file through the repl" do |file_name|
-        s.non_interactive_mode(_pry_, File.read(File.expand_path(file_name)))
-      end
-    end
-
-    # Actually load the file through the REPL by setting file content
-    # as the REPL input stream.
-    def load
-      non_interactive_mode(Pry.new, @content)
-    end
-  end
-end

data/path/gems/pry-0.10.1-x86-mingw32/lib/pry/rubygem.rb

@@ -1,82 +0,0 @@
-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
-
-        first_spec = specs.sort_by{ |spec| Gem::Version.new(spec.version) }.last
-
-        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)
-        gemrc_opts = Gem.configuration['gem'].split(' ')
-        destination = if gemrc_opts.include?('--user-install')
-                        Gem.user_dir
-                      elsif File.writable?(Gem.dir)
-                        Gem.dir
-                      else
-                        Gem.user_dir
-                      end
-        installer = Gem::DependencyInstaller.new(:install_dir => destination)
-        installer.install(name)
-      rescue Errno::EACCES
-        raise CommandError,
-          "Insufficient permissions to install #{ Pry::Helpers::Text.green(name) }."
-      rescue Gem::GemNotFoundException
-        raise CommandError,
-          "Gem #{ Pry::Helpers::Text.green(name) } not found. Aborting installation."
-      else
-        Gem.refresh
-      end
-    end
-
-  end
-end

data/path/gems/pry-0.10.1-x86-mingw32/lib/pry/terminal.rb

@@ -1,79 +0,0 @@
-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.to_i != 0 && cols.to_i != 0
-        [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 probably don't have the io/console stdlib or 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 defined?(Readline) && 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