RubyGems - vagrant-shell - Versions diffs - 0.2.9 → 0.2.11 - Mend

vagrant-shell 0.2.9 → 0.2.11

Files changed (1838) hide show

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/README.md DELETED Viewed

@@ -1,150 +0,0 @@
-# childprocess
-This gem aims at being a simple and reliable solution for controlling
-external programs running in the background on any Ruby / OS combination.
-The code originated in the [selenium-webdriver](https://rubygems.org/gems/selenium-webdriver) gem, but should prove useful as
-a standalone library.
-[![Build Status](https://secure.travis-ci.org/jarib/childprocess.png)](http://travis-ci.org/jarib/childprocess)
-# Usage
-The object returned from `ChildProcess.build` will implement `ChildProcess::AbstractProcess`.
-### Basic examples
-```ruby
-process = ChildProcess.build("ruby", "-e", "sleep")
-# inherit stdout/stderr from parent...
-process.io.inherit!
-# ...or pass an IO
-process.io.stdout = Tempfile.new("child-output")
-# modify the environment for the child
-process.environment["a"] = "b"
-process.environment["c"] = nil
-# set the child's working directory
-process.cwd = '/some/path'
-# start the process
-process.start
-# check process status
-process.alive?    #=> true
-process.exited?   #=> false
-# wait indefinitely for process to exit...
-process.wait
-process.exited?   #=> true
-# get the exit code
-process.exit_code #=> 0
-# ...or poll for exit + force quit
-begin
-  process.poll_for_exit(10)
-rescue ChildProcess::TimeoutError
-  process.stop # tries increasingly harsher methods to kill the process.
-end
-```
-### Advanced examples
-#### Output to pipe
-```ruby
-r, w = IO.pipe
-proc = ChildProcess.build("echo", "foo")
-proc.io.stdout = proc.io.stderr = w
-proc.start
-w.close
-begin
-  loop { print r.readpartial(8192) }
-rescue EOFError
-end
-proc.wait
-```
-Note that if you just want to get the output of a command, the backtick method on Kernel may be a better fit.
-#### Write to stdin
-```ruby
-process = ChildProcess.build("cat")
-out      = Tempfile.new("duplex")
-out.sync = true
-process.io.stdout = process.io.stderr = out
-process.duplex    = true # sets up pipe so process.io.stdin will be available after .start
-process.start
-process.io.stdin.puts "hello world"
-process.io.stdin.close
-process.poll_for_exit(exit_timeout_in_seconds)
-out.rewind
-out.read #=> "hello world\n"
-```
-#### Pipe output to another ChildProcess
-```ruby
-search           = ChildProcess.build("grep", '-E', %w(redis memcached).join('|'))
-search.duplex    = true # sets up pipe so search.io.stdin will be available after .start
-search.io.stdout = $stdout
-search.start
-listing           = ChildProcess.build("ps", "aux")
-listing.io.stdout = search.io.stdin
-listing.start
-listing.wait
-search.io.stdin.close
-search.wait
-```
-#### Prefer posix_spawn on *nix
-If the parent process is using a lot of memory, `fork+exec` can be very expensive. The `posix_spawn()` API removes this overhead.
-```ruby
-ChildProcess.posix_spawn = true
-process = ChildProcess.build(*args)
-```
-#### Detach from parent
-```ruby
-process = ChildProcess.build("sleep", "10")
-process.detach = true
-process.start
-```
-# Implementation
-How the process is launched and killed depends on the platform:
-* Unix     : `fork + exec` (or `posix_spawn` if enabled)
-* Windows  : `CreateProcess()` and friends
-* JRuby    : `java.lang.{Process,ProcessBuilder}`
-# Note on Patches/Pull Requests
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a future version unintentionally.
-* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-# Copyright
-Copyright (c) 2010-2013 Jari Bakken. See LICENSE for details.

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/Rakefile DELETED Viewed

@@ -1,61 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'tmpdir'
-require 'bundler'
-Bundler::GemHelper.install_tasks
-include Rake::DSL if defined?(::Rake::DSL)
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.ruby_opts  = "-I lib:spec"
-  spec.pattern    = 'spec/**/*_spec.rb'
-end
-desc 'Run specs for rcov'
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.ruby_opts = "-I lib:spec"
-  spec.pattern   = 'spec/**/*_spec.rb'
-  spec.rcov      = true
-  spec.rcov_opts = %w[--exclude spec,ruby-debug,/Library/Ruby,.gem --include lib/childprocess]
-end
-task :default => :spec
-begin
-  require 'yard'
-  YARD::Rake::YardocTask.new
-rescue LoadError
-  task :yardoc do
-    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
-  end
-end
-task :clean do
-  rm_rf "pkg"
-  rm_rf "childprocess.jar"
-end
-desc 'Create jar to bundle in selenium-webdriver'
-task :jar => [:clean, :build] do
-  tmpdir = Dir.mktmpdir("childprocess-jar")
-  gem_to_package = Dir['pkg/*.gem'].first
-  gem_name = File.basename(gem_to_package, ".gem")
-  p :gem_to_package => gem_to_package, :gem_name => gem_name
-  sh "gem install -i #{tmpdir} #{gem_to_package} --ignore-dependencies --no-rdoc --no-ri"
-  sh "jar cf childprocess.jar -C #{tmpdir}/gems/#{gem_name}/lib ."
-  sh "jar tf childprocess.jar"
-end
-task :env do
-  $:.unshift File.expand_path("../lib", __FILE__)
-  require 'childprocess'
-end
-desc 'Calculate size of posix_spawn structs for the current platform'
-task :generate => :env do
-  require 'childprocess/tools/generator'
-  ChildProcess::Tools::Generator.generate
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/childprocess.gemspec DELETED Viewed

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "childprocess/version"
-Gem::Specification.new do |s|
-  s.name        = "childprocess"
-  s.version     = ChildProcess::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Jari Bakken"]
-  s.email       = ["jari.bakken@gmail.com"]
-  s.homepage    = "http://github.com/jarib/childprocess"
-  s.summary     = %q{This gem aims at being a simple and reliable solution for controlling external programs running in the background on any Ruby / OS combination.}
-  s.description = %q{This gem aims at being a simple and reliable solution for controlling external programs running in the background on any Ruby / OS combination.}
-  s.rubyforge_project = "childprocess"
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- spec/*`.split("\n")
-  s.require_paths = ["lib"]
-  s.add_development_dependency "rspec", ">= 2.0.0"
-  s.add_development_dependency "yard", ">= 0"
-  s.add_development_dependency "rake", "~> 0.9.2"
-  s.add_runtime_dependency "ffi", "~> 1.0", ">= 1.0.11"
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/lib/childprocess/abstract_io.rb DELETED Viewed

@@ -1,36 +0,0 @@
-module ChildProcess
-  class AbstractIO
-    attr_reader :stderr, :stdout, :stdin
-    def inherit!
-      @stdout = STDOUT
-      @stderr = STDERR
-    end
-    def stderr=(io)
-      check_type io
-      @stderr = io
-    end
-    def stdout=(io)
-      check_type io
-      @stdout = io
-    end
-    #
-    # @api private
-    #
-    def _stdin=(io)
-      check_type io
-      @stdin = io
-    end
-    private
-    def check_type(io)
-      raise SubclassResponsibility, "check_type"
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/lib/childprocess/abstract_process.rb DELETED Viewed

@@ -1,173 +0,0 @@
-module ChildProcess
-  class AbstractProcess
-    POLL_INTERVAL = 0.1
-    attr_reader :exit_code
-    #
-    # Set this to true if you do not care about when or if the process quits.
-    #
-    attr_accessor :detach
-    #
-    # Set this to true if you want to write to the process' stdin (process.io.stdin)
-    #
-    attr_accessor :duplex
-    #
-    # Modify the child's environment variables
-    #
-    attr_reader :environment
-    #
-    # Set the child's current working directory.
-    #
-    attr_accessor :cwd
-    #
-    # Create a new process with the given args.
-    #
-    # @api private
-    # @see ChildProcess.build
-    #
-    def initialize(args)
-      unless args.all? { |e| e.kind_of?(String) }
-        raise ArgumentError, "all arguments must be String: #{args.inspect}"
-      end
-      @args        = args
-      @started     = false
-      @exit_code   = nil
-      @io          = nil
-      @cwd         = nil
-      @detach      = false
-      @duplex      = false
-      @environment = {}
-    end
-    #
-    # Returns a ChildProcess::AbstractIO subclass to configure the child's IO streams.
-    #
-    def io
-      raise SubclassResponsibility, "io"
-    end
-    #
-    # @return [Fixnum] the pid of the process after it has started
-    #
-    def pid
-      raise SubclassResponsibility, "pid"
-    end
-    #
-    # Launch the child process
-    #
-    # @return [AbstractProcess] self
-    #
-    def start
-      launch_process
-      @started = true
-      self
-    end
-    #
-    # Forcibly terminate the process, using increasingly harsher methods if possible.
-    #
-    # @param [Fixnum] timeout (3) Seconds to wait before trying the next method.
-    #
-    def stop(timeout = 3)
-      raise SubclassResponsibility, "stop"
-    end
-    #
-    # Block until the process has been terminated.
-    #
-    # @return [Fixnum] The exit status of the process
-    #
-    def wait
-      raise SubclassResponsibility, "wait"
-    end
-    #
-    # Did the process exit?
-    #
-    # @return [Boolean]
-    #
-    def exited?
-      raise SubclassResponsibility, "exited?"
-    end
-    #
-    # Is this process running?
-    #
-    # @return [Boolean]
-    #
-    def alive?
-      started? && !exited?
-    end
-    #
-    # Returns true if the process has exited and the exit code was not 0.
-    #
-    # @return [Boolean]
-    #
-    def crashed?
-      exited? && @exit_code != 0
-    end
-    #
-    # Wait for the process to exit, raising a ChildProcess::TimeoutError if
-    # the timeout expires.
-    #
-    def poll_for_exit(timeout)
-      log "polling #{timeout} seconds for exit"
-      end_time = Time.now + timeout
-      until (ok = exited?) || Time.now > end_time
-        sleep POLL_INTERVAL
-      end
-      unless ok
-        raise TimeoutError, "process still alive after #{timeout} seconds"
-      end
-    end
-    private
-    def launch_process
-      raise SubclassResponsibility, "launch_process"
-    end
-    def started?
-      @started
-    end
-    def detach?
-      @detach
-    end
-    def duplex?
-      @duplex
-    end
-    def log(*args)
-      $stderr.puts "#{self.inspect} : #{args.inspect}" if $DEBUG
-    end
-    def assert_started
-      raise Error, "process not started" unless started?
-    end
-  end # AbstractProcess
-end # ChildProcess

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/lib/childprocess/errors.rb DELETED Viewed

@@ -1,26 +0,0 @@
-module ChildProcess
-  class Error < StandardError
-  end
-  class TimeoutError < Error
-  end
-  class SubclassResponsibility < Error
-  end
-  class InvalidEnvironmentVariable < Error
-  end
-  class LaunchError < Error
-  end
-  class MissingPlatformError < Error
-    def initialize
-      message = "posix_spawn is not yet supported on #{ChildProcess.platform_name} (#{RUBY_PLATFORM}), falling back to default implementation. " +
-                "If you believe this is an error, please file a bug at http://github.com/jarib/childprocess/issues"
-      super(message)
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/lib/childprocess/jruby/io.rb DELETED Viewed

@@ -1,16 +0,0 @@
-module ChildProcess
-  module JRuby
-    class IO < AbstractIO
-      private
-      def check_type(output)
-        unless output.respond_to?(:to_outputstream) && output.respond_to?(:write)
-          raise ArgumentError, "expected #{output.inspect} to respond to :to_outputstream"
-        end
-      end
-    end # IO
-  end # Unix
-end # ChildProcess

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/lib/childprocess/jruby/process.rb DELETED Viewed

@@ -1,143 +0,0 @@
-require "java"
-module ChildProcess
-  module JRuby
-    class Process < AbstractProcess
-      def initialize(args)
-        super(args)
-        @pumps = []
-      end
-      def io
-        @io ||= JRuby::IO.new
-      end
-      def exited?
-        return true if @exit_code
-        assert_started
-        @exit_code = @process.exitValue
-        stop_pumps
-        true
-      rescue java.lang.IllegalThreadStateException
-        false
-      ensure
-        log(:exit_code => @exit_code)
-      end
-      def stop(timeout = nil)
-        assert_started
-        @process.destroy
-        wait # no way to actually use the timeout here..
-      end
-      def wait
-        @process.waitFor
-        stop_pumps
-        @exit_code = @process.exitValue
-      end
-      #
-      # Only supported in JRuby on a Unix operating system, thanks to limitations
-      # in Java's classes
-      #
-      # @return [Fixnum] the pid of the process after it has started
-      # @raise [NotImplementedError] when trying to access pid on non-Unix platform
-      #
-      def pid
-        if @process.getClass.getName != "java.lang.UNIXProcess"
-          raise NotImplementedError, "pid is only supported by JRuby child processes on Unix"
-        end
-        # About the best way we can do this is with a nasty reflection-based impl
-        # Thanks to Martijn Courteaux
-        # http://stackoverflow.com/questions/2950338/how-can-i-kill-a-linux-process-in-java-with-sigkill-process-destroy-does-sigter/2951193#2951193
-        field = @process.getClass.getDeclaredField("pid")
-        field.accessible = true
-        field.get(@process)
-      end
-      private
-      def launch_process(&blk)
-        pb = java.lang.ProcessBuilder.new(@args)
-        pb.directory java.io.File.new(@cwd || Dir.pwd)
-        set_env pb.environment
-        begin
-          @process = pb.start
-        rescue java.io.IOException => ex
-          raise LaunchError, ex.message
-        end
-        setup_io
-      end
-      def setup_io
-        if @io
-          redirect(@process.getErrorStream, @io.stderr)
-          redirect(@process.getInputStream, @io.stdout)
-        else
-          @process.getErrorStream.close
-          @process.getInputStream.close
-        end
-        if duplex?
-          io._stdin = create_stdin
-        else
-          @process.getOutputStream.close
-        end
-      end
-      def redirect(input, output)
-        if output.nil?
-          input.close
-          return
-        end
-        @pumps << Pump.new(input, output.to_outputstream).run
-      end
-      def stop_pumps
-        @pumps.each { |pump| pump.stop }
-      end
-      def set_env(env)
-        ENV.to_hash.merge(@environment).each do |k,v|
-          env.put(k.to_s, v.to_s) if v
-        end
-      end
-      def create_stdin
-        output_stream = @process.getOutputStream
-        stdin = output_stream.to_io
-        stdin.sync = true
-        stdin.instance_variable_set(:@childprocess_java_stream, output_stream)
-        class << stdin
-          # The stream provided is a BufferedeOutputStream, so we
-          # have to flush it to make the bytes flow to the process
-          def __childprocess_flush__
-            @childprocess_java_stream.flush
-          end
-          [:flush, :print, :printf, :putc, :puts, :write, :write_nonblock].each do |m|
-            define_method(m) do |*args|
-              super(*args)
-              self.__childprocess_flush__
-            end
-          end
-        end
-        stdin
-      end
-    end # Process
-  end # JRuby
-end # ChildProcess

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/childprocess-0.3.9/lib/childprocess/jruby/pump.rb DELETED Viewed

@@ -1,52 +0,0 @@
-module ChildProcess
-  module JRuby
-    class Pump
-      BUFFER_SIZE = 2048
-      def initialize(input, output)
-        @input  = input
-        @output = output
-        @stop   = false
-      end
-      def stop
-        @stop = true
-        @thread && @thread.join
-      end
-      def run
-        @thread = Thread.new { pump }
-        self
-      end
-      private
-      def pump
-        buffer = Java.byte[BUFFER_SIZE].new
-        until @stop && (@input.available == 0)
-          read, avail = 0, 0
-          while read != -1
-            avail = [@input.available, 1].max
-            avail = BUFFER_SIZE if avail > BUFFER_SIZE
-            read = @input.read(buffer, 0, avail)
-            if read > 0
-              @output.write(buffer, 0, read)
-              @output.flush
-            end
-          end
-          sleep 0.1
-        end
-        @output.flush
-      rescue java.io.IOException => ex
-        $stderr.puts ex.message, ex.backtrace if $DEBUG
-      end
-    end # Pump
-  end # JRuby
-end # ChildProcess