vagrant-shell 0.2.9 → 0.2.11

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/net-scp-1.1.1/README.rdoc

@@ -1,118 +0,0 @@
-= Net::SCP
-
-* Docs: http://net-ssh.github.com/net-scp
-* Issues: https://github.com/net-ssh/net-scp/issues
-* Codes: https://github.com/net-ssh/net-scp
-* Email: net-ssh@solutious.com
-
-<em>As of v1.0.5, all gem releases are signed. See INSTALL.</em>
-
-
-== DESCRIPTION:
-
-Net::SCP is a pure-Ruby implementation of the SCP protocol. This operates over SSH (and requires the Net::SSH library), and allows files and directory trees to copied to and from a remote server.
-
-== FEATURES/PROBLEMS:
-
-* Transfer files or entire directory trees to or from a remote host via SCP
-* Can preserve file attributes across transfers
-* Can download files in-memory, or direct-to-disk
-* Support for SCP URI's, and OpenURI
-
-== SYNOPSIS:
-
-In a nutshell:
-
-  require 'net/scp'
-
-  # upload a file to a remote server
-  Net::SCP.upload!("remote.host.com", "username",
-    "/local/path", "/remote/path",
-    :password => "password")
-
-  # download a file from a remote server
-  Net::SCP.download!("remote.host.com", "username",
-    "/remote/path", "/local/path",
-    :password => password)
-
-  # download a file to an in-memory buffer
-  data = Net::SCP::download!("remote.host.com", "username", "/remote/path")
-
-  # use a persistent connection to transfer files
-  Net::SCP.start("remote.host.com", "username", :password => "password") do |scp|
-    # upload a file to a remote server
-    scp.upload! "/local/path", "/remote/path"
-
-    # upload from an in-memory buffer
-    scp.upload! StringIO.new("some data to upload"), "/remote/path"
-
-    # run multiple downloads in parallel
-    d1 = scp.download("/remote/path", "/local/path")
-    d2 = scp.download("/remote/path2", "/local/path2")
-    [d1, d2].each { |d| d.wait }
-  end
-
-  # You can also use open-uri to grab data via scp:
-  require 'uri/open-scp'
-  data = open("scp://user@host/path/to/file.txt").read
-
-For more information, see Net::SCP.
-
-== REQUIREMENTS:
-
-* Net::SSH 2
-
-If you wish to run the tests, you'll also need:
-
-* Echoe (for Rakefile use)
-* Mocha (for tests)
-
-== INSTALL:
-
-* gem install net-scp (might need sudo privileges)
-
-However, in order to be sure the code you're installing hasn't been tampered with, it's recommended that you verify the signiture[http://docs.rubygems.org/read/chapter/21]. To do this, you need to add my public key as a trusted certificate (you only need to do this once):
-
-    # Add the public key as a trusted certificate
-    # (You only need to do this once)
-    $ curl -O https://raw.github.com/net-ssh/net-ssh/master/gem-public_cert.pem
-    $ gem cert --add gem-public_cert.pem
-
-Then, when install the gem, do so with high security:
-
-    $ gem install net-scp -P HighSecurity
-
-If you don't add the public key, you'll see an error like "Couldn't verify data signature". If you're still having trouble let me know and I'll give you a hand.
-
-
-Or, you can do it the hard way (without Rubygems):
-
-* tar xzf net-scp-*.tgz
-* cd net-scp-*
-* ruby setup.rb config
-* ruby setup.rb install (might need sudo privileges)
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2008 Jamis Buck <jamis@37signals.com>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/net-scp-1.1.1/Rakefile

@@ -1,60 +0,0 @@
-require "rubygems"
-require "rake"
-require "rake/clean"
-require "rdoc/task"
-
-task :default => ["build"]
-CLEAN.include [ 'pkg', 'rdoc' ]
-name = "net-scp"
-
-$:.unshift File.join(File.dirname(__FILE__), 'lib')
-require "net/scp/version"
-version = Net::SCP::Version::STRING.dup
-
-begin
-  require "jeweler"
-  Jeweler::Tasks.new do |s|
-    s.version = version
-    s.name = name
-    s.rubyforge_project = s.name
-    s.summary = "A pure Ruby implementation of the SCP client protocol"
-    s.description = s.summary
-    s.email = "net-ssh@solutious.com"
-    s.homepage = "https://github.com/net-ssh/net-scp"
-    s.authors = ["Jamis Buck", "Delano Mandelbaum"]
-
-    s.add_dependency 'net-ssh', ">=2.6.5"
-
-    s.add_development_dependency 'test-unit'
-    s.add_development_dependency 'mocha'
-
-    s.license = "MIT"
-
-    s.signing_key = File.join('/mnt/gem/', 'gem-private_key.pem')
-    s.cert_chain  = ['gem-public_cert.pem']
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'rake/testtask'
-Rake::TestTask.new do |t|
-  t.libs = ["lib", "test"]
-end
-
-extra_files = %w[LICENSE.txt THANKS.txt CHANGES.txt ]
-RDoc::Task.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.title = "#{name} #{version}"
-  rdoc.generator = 'hanna' # gem install hanna-nouveau
-  rdoc.main = 'README.rdoc'
-  rdoc.rdoc_files.include("README*")
-  rdoc.rdoc_files.include("bin/*.rb")
-  rdoc.rdoc_files.include("lib/**/*.rb")
-  extra_files.each { |file|
-    rdoc.rdoc_files.include(file) if File.exists?(file)
-  }
-end
-
-

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/net-scp-1.1.1/gem-public_cert.pem

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMQ8wDQYDVQQDDAZkZWxh
-bm8xGTAXBgoJkiaJk/IsZAEZFglzb2x1dGlvdXMxEzARBgoJkiaJk/IsZAEZFgNj
-b20wHhcNMTMwMjA2MTE1NzQ1WhcNMTQwMjA2MTE1NzQ1WjBBMQ8wDQYDVQQDDAZk
-ZWxhbm8xGTAXBgoJkiaJk/IsZAEZFglzb2x1dGlvdXMxEzARBgoJkiaJk/IsZAEZ
-FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDg1hMtl0XsMuUK
-AKTgYWv3gjj7vuEsE2EjT+vyBg8/LpqVVwZziiaebJT9IZiQ+sCFqbiakj0b53pI
-hg1yOaBEmH6/W0L7rwzqaRV9sW1eJs9JxFYQCnd67zUnzj8nnRlOjG+hhIG+Vsij
-npsGbt28pefuNZJjO5q2clAlfSniIIHfIsU7/StEYu6FUGOjnwryZ0r5yJlr9RrE
-Gs+q0DW8QnZ9UpAfuDFQZuIqeKQFFLE7nMmCGaA+0BN1nLl3fVHNbLHq7Avk8+Z+
-ZuuvkdscbHlO/l+3xCNQ5nUnHwq0ADAbMLOlmiYYzqXoWLjmeI6me/clktJCfN2R
-oZG3UQvvAgMBAAGjOTA3MAkGA1UdEwQCMAAwHQYDVR0OBBYEFMSJOEtHzE4l0azv
-M0JK0kKNToK1MAsGA1UdDwQEAwIEsDANBgkqhkiG9w0BAQUFAAOCAQEAtOdE73qx
-OH2ydi9oT2hS5f9G0y1Z70Tlwh+VGExyfxzVE9XwC+iPpJxNraiHYgF/9/oky7ZZ
-R9q0/tJneuhAenZdiQkX7oi4O3v9wRS6YHoWBxMPFKVRLNTzvVJsbmfpCAlp5/5g
-ps4wQFy5mibElGVlOobf/ghqZ25HS9J6kd0/C/ry0AUtTogsL7TxGwT4kbCx63ub
-3vywEEhsJUzfd97GCABmtQfRTldX/j7F1z/5wd8p+hfdox1iibds9ZtfaZA3KzKn
-kchWN9B6zg9r1XMQ8BM2Jz0XoPanPe354+lWwjpkRKbFow/ZbQHcCLCq24+N6b6g
-dgKfNDzwiDpqCA==
------END CERTIFICATE-----

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/net-scp-1.1.1/lib/net/scp/download.rb

@@ -1,150 +0,0 @@
-require 'net/scp/errors'
-
-module Net; class SCP
-
-  # This module implements the state machine for downloading information from
-  # a remote server. It exposes no public methods. See Net::SCP#download for
-  # a discussion of how to use Net::SCP to download data.
-  module Download
-    private
-
-    # This is the starting state for the download state machine. The
-    # #start_command method puts the state machine into this state the first
-    # time the channel is processed. This state does some basic error checking
-    # and scaffolding and then sends a 0-byte to the remote server, indicating
-    # readiness to proceed. Then, the state machine is placed into the
-    # "read directive" state (see #read_directive_state).
-    def download_start_state(channel)
-      if channel[:local].respond_to?(:write) && channel[:options][:recursive]
-        raise Net::SCP::Error, "cannot recursively download to an in-memory location"
-      elsif channel[:local].respond_to?(:write) && channel[:options][:preserve]
-        lwarn { ":preserve option is ignored when downloading to an in-memory buffer" }
-        channel[:options].delete(:preserve)
-      elsif channel[:options][:recursive] && !File.exists?(channel[:local])
-        Dir.mkdir(channel[:local])
-      end
-
-      channel.send_data("\0")
-      channel[:state] = :read_directive
-    end
-
-    # This state parses the next full line (up to a new-line) for the next
-    # directive. (See the SCP protocol documentation in Net::SCP for the
-    # possible directives).
-    def read_directive_state(channel)
-      return unless line = channel[:buffer].read_to("\n")
-      channel[:buffer].consume!
-
-      directive = parse_directive(line)
-      case directive[:type]
-      when :times then
-        channel[:times] = directive
-      when :directory
-        read_directory(channel, directive)
-      when :file
-        read_file(channel, directive)
-      when :end
-        channel[:local] = File.dirname(channel[:local])
-        channel[:stack].pop
-        channel[:state] = :finish if channel[:stack].empty?
-      end
-
-      channel.send_data("\0")
-    end
-
-    # Reads data from the channel for as long as there is data remaining to
-    # be read. As soon as there is no more data to read for the current file,
-    # the state machine switches to #finish_read_state.
-    def read_data_state(channel)
-      return if channel[:buffer].empty?
-      data = channel[:buffer].read!(channel[:remaining])
-      channel[:io].write(data)
-      channel[:remaining] -= data.length
-      progress_callback(channel, channel[:file][:name], channel[:file][:size] - channel[:remaining], channel[:file][:size])
-      await_response(channel, :finish_read) if channel[:remaining] <= 0
-    end
-
-    # Finishes off the read, sets the times for the file (if any), and then
-    # jumps to either #finish_state (for single-file downloads) or
-    # #read_directive_state (for recursive downloads). A 0-byte is sent to the
-    # server to indicate that the file was recieved successfully.
-    def finish_read_state(channel)
-      channel[:io].close unless channel[:io] == channel[:local]
-
-      if channel[:options][:preserve] && channel[:file][:times]
-        File.utime(channel[:file][:times][:atime],
-          channel[:file][:times][:mtime], channel[:file][:name])
-      end
-
-      channel[:file] = nil
-      channel[:state] = channel[:stack].empty? ? :finish : :read_directive
-      channel.send_data("\0")
-    end
-
-    # Parses the given +text+ to extract which SCP directive it contains. It
-    # then returns a hash with at least one key, :type, which describes what
-    # type of directive it is. The hash may also contain other, directive-specific
-    # data.
-    def parse_directive(text)
-      case type = text[0]
-      when ?T
-        parts = text[1..-1].split(/ /, 4).map { |i| i.to_i }
-        { :type  => :times,
-          :mtime => Time.at(parts[0], parts[1]),
-          :atime => Time.at(parts[2], parts[3]) }
-      when ?C, ?D
-        parts = text[1..-1].split(/ /, 3)
-        { :type => (type == ?C ? :file : :directory),
-          :mode => parts[0].to_i(8),
-          :size => parts[1].to_i,
-          :name => parts[2].chomp }
-      when ?E
-        { :type => :end }
-      else raise ArgumentError, "unknown directive: #{text.inspect}"
-      end
-    end
-
-    # Sets the new directory as the current directory, creates the directory
-    # if it does not exist, and then falls back into #read_directive_state.
-    def read_directory(channel, directive)
-      if !channel[:options][:recursive]
-        raise Net::SCP::Error, ":recursive not specified for directory download"
-      end
-
-      channel[:local] = File.join(channel[:local], directive[:name])
-
-      if File.exists?(channel[:local]) && !File.directory?(channel[:local])
-        raise "#{channel[:local]} already exists and is not a directory"
-      elsif !File.exists?(channel[:local])
-        Dir.mkdir(channel[:local], directive[:mode] | 0700)
-      end
-
-      if channel[:options][:preserve] && channel[:times]
-        File.utime(channel[:times][:atime], channel[:times][:mtime], channel[:local])
-      end
-
-      channel[:stack] << directive
-      channel[:times] = nil
-    end
-
-    # Opens the given file locally, and switches to #read_data_state to do the
-    # actual read.
-    def read_file(channel, directive)
-      if !channel[:local].respond_to?(:write)
-        directive[:name] = (channel[:options][:recursive] || File.directory?(channel[:local])) ?
-          File.join(channel[:local], directive[:name]) :
-          channel[:local]
-      end
-
-      channel[:file] = directive.merge(:times => channel[:times])
-      channel[:io] = channel[:local].respond_to?(:write) ? channel[:local] :
-        File.new(directive[:name], "wb", directive[:mode] | 0600)
-      channel[:times] = nil
-      channel[:remaining] = channel[:file][:size]
-      channel[:state] = :read_data
-
-      progress_callback(channel, channel[:file][:name], 0, channel[:file][:size])
-    end
-  end
-
-end; end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/net-scp-1.1.1/lib/net/scp/errors.rb

@@ -1,5 +0,0 @@
-module Net; class SCP
-
-  class Error < RuntimeError; end
-
-end; end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/net-scp-1.1.1/lib/net/scp/upload.rb

@@ -1,142 +0,0 @@
-require 'net/scp/errors'
-
-module Net; class SCP
-
-  # This module implements the state machine for uploading information to
-  # a remote server. It exposes no public methods. See Net::SCP#upload for
-  # a discussion of how to use Net::SCP to upload data.
-  module Upload
-    private
-
-    # The default read chunk size, if an explicit chunk-size is not specified
-    # by the client.
-    DEFAULT_CHUNK_SIZE = 16384
-
-    # The start state for uploads. Simply sets up the upload scaffolding,
-    # sets the current item to upload, and jumps to #upload_current_state.
-    def upload_start_state(channel)
-      if channel[:local].respond_to?(:read)
-        channel[:options].delete(:recursive)
-        channel[:options].delete(:preserve)
-      end
-
-      channel[:chunk_size] = channel[:options][:chunk_size] || DEFAULT_CHUNK_SIZE
-      set_current(channel, channel[:local])
-      await_response(channel, :upload_current)
-    end
-
-    # Determines what the next thing to upload is, and branches. If the next
-    # item is a file, goes to #upload_file_state. If it is a directory, goes
-    # to #upload_directory_state.
-    def upload_current_state(channel)
-      if channel[:current].respond_to?(:read)
-        upload_file_state(channel)
-      elsif File.directory?(channel[:current])
-        raise Net::SCP::Error, "can't upload directories unless :recursive" unless channel[:options][:recursive]
-        upload_directory_state(channel)
-      elsif File.file?(channel[:current])
-        upload_file_state(channel)
-      else
-        raise Net::SCP::Error, "not a directory or a regular file: #{channel[:current].inspect}"
-      end
-    end
-
-    # After transferring attributes (if requested), sends a 'D' directive and
-    # awaites the server's 0-byte response. Then goes to #next_item_state.
-    def upload_directory_state(channel)
-      if preserve_attributes_if_requested(channel)
-        mode = channel[:stat].mode & 07777
-        directive = "D%04o %d %s\n" % [mode, 0, File.basename(channel[:current])]
-        channel.send_data(directive)
-        channel[:cwd] = channel[:current]
-        channel[:stack] << Dir.entries(channel[:current]).reject { |i| i == "." || i == ".." }
-        await_response(channel, :next_item)
-      end
-    end
-
-    # After transferring attributes (if requested), sends a 'C' directive and
-    # awaits the server's 0-byte response. Then goes to #send_data_state.
-    def upload_file_state(channel)
-      if preserve_attributes_if_requested(channel)
-        mode = channel[:stat] ? channel[:stat].mode & 07777 : channel[:options][:mode]
-        channel[:name] = channel[:current].respond_to?(:read) ? channel[:remote] : channel[:current]
-        directive = "C%04o %d %s\n" % [mode || 0640, channel[:size], File.basename(channel[:name])]
-        channel.send_data(directive)
-        channel[:io] = channel[:current].respond_to?(:read) ? channel[:current] : File.open(channel[:current], "rb")
-        channel[:sent] = 0
-        progress_callback(channel, channel[:name], channel[:sent], channel[:size])
-        await_response(channel, :send_data)
-      end
-    end
-
-    # If any data remains to be transferred from the current file, sends it.
-    # Otherwise, sends a 0-byte and transfers to #next_item_state.
-    def send_data_state(channel)
-      data = channel[:io].read(channel[:chunk_size])
-      if data.nil?
-        channel[:io].close unless channel[:local].respond_to?(:read)
-        channel.send_data("\0")
-        await_response(channel, :next_item)
-      else
-        channel[:sent] += data.length
-        progress_callback(channel, channel[:name], channel[:sent], channel[:size])
-        channel.send_data(data)
-      end
-    end
-
-    # Checks the work queue to see what needs to be done next. If there is
-    # nothing to do, calls Net::SCP#finish_state. If we're at the end of a
-    # directory, sends an 'E' directive and waits for the server to respond
-    # before moving to #next_item_state. Otherwise, sets the next thing to
-    # upload and moves to #upload_current_state.
-    def next_item_state(channel)
-      if channel[:stack].empty?
-        finish_state(channel)
-      else
-        next_item = channel[:stack].last.shift
-        if next_item.nil?
-          channel[:stack].pop
-          channel[:cwd] = File.dirname(channel[:cwd])
-          channel.send_data("E\n")
-          await_response(channel, channel[:stack].empty? ? :finish : :next_item)
-        else
-          set_current(channel, next_item)
-          upload_current_state(channel)
-        end
-      end
-    end
-
-    # Sets the given +path+ as the new current item to upload.
-    def set_current(channel, path)
-      path = channel[:cwd] ? File.join(channel[:cwd], path) : path
-      channel[:current] = path
-
-      if channel[:current].respond_to?(:read)
-        channel[:stat] = channel[:current].stat if channel[:current].respond_to?(:stat)
-      else
-        channel[:stat] = File.stat(channel[:current])
-      end
-
-      channel[:size] = channel[:stat] ? channel[:stat].size : channel[:current].size
-    end
-
-    # If the :preserve option is set, send a 'T' directive and wait for the
-    # server to respond before proceeding to either #upload_file_state or
-    # #upload_directory_state, depending on what is being uploaded.
-    def preserve_attributes_if_requested(channel)
-      if channel[:options][:preserve] && !channel[:preserved]
-        channel[:preserved] = true
-        stat = channel[:stat]
-        directive = "T%d %d %d %d\n" % [stat.mtime.to_i, stat.mtime.usec, stat.atime.to_i, stat.atime.usec]
-        channel.send_data(directive)
-        type = stat.directory? ? :directory : :file
-        await_response(channel, "upload_#{type}")
-        return false
-      else
-        channel[:preserved] = false
-        return true
-      end
-    end
-  end
-
-end; end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/net-scp-1.1.1/lib/net/scp/version.rb

@@ -1,18 +0,0 @@
-require 'net/ssh/version'
-
-module Net; class SCP
-
-  # Describes the current version of the Net::SCP library.
-  class Version < Net::SSH::Version
-    MAJOR = 1
-    MINOR = 1
-    TINY  = 1
-
-    # The current version, as a Version instance
-    CURRENT = new(MAJOR, MINOR, TINY)
-
-    # The current version, as a String instance
-    STRING  = CURRENT.to_s
-  end
-
-end; end