vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'guard-rspec', '~> 4.7.3'
+  gem 'pry-nav', '~> 0.2.4'
+  gem 'rake', '~> 12.0.0'
+  gem 'rspec', '~> 3.6.0'
+  gem 'rubocop', '~> 0.49.1'
+  gem 'simplecov', '~> 0.14.1', require: false
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/Guardfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', version: 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { 'spec' }
+  watch(%r{^spec/support/(.+)\.rb$}) { 'spec' }
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License
+
+Copyright (c) 2017 Eric Saxby
+
+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/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/README.md

@@ -0,0 +1,101 @@
+# FakeFtp
+
+[![Build status](https://api.travis-ci.org/livinginthepast/fake_ftp.svg?branch=master)](http://travis-ci.org/livinginthepast/fake_ftp)
+
+This is a gem that allows you to test FTP implementations in ruby. It is a
+minimal single-client FTP server that can be bound to any arbitrary port on
+localhost.
+
+## Why?
+
+We want to ensure that our code works, in a way that is agnostic to the
+implementation used (unlike with stubs or mocks).
+
+## How
+
+FakeFtp is a simple FTP server that fakes out enough of the protocol to get us
+by, allowing us to test that files get to their intended destination rather than
+testing how our code does so.
+
+## Usage
+
+To test passive upload:
+``` ruby
+require 'fake_ftp'
+require 'net/ftp'
+
+server = FakeFtp::Server.new(21212, 21213)
+## 21212 is the control port, which is used by FTP for the primary connection
+## 21213 is the data port, used in FTP passive mode to send file contents
+server.start
+
+ftp = Net::FTP.new
+ftp.connect('127.0.0.1', 21212)
+ftp.login('user', 'password')
+ftp.passive = true
+ftp.put('some_file.txt')
+ftp.close
+
+expect(server.files).to include('some_file.txt')
+expect(server.file('some_file.txt').bytes).to eq 25
+expect(server.file('some_file.txt')).to be_passive
+expect(server.file('some_file.txt')).not_not be_active
+
+server.stop
+```
+
+To test active upload:
+``` ruby
+server = FakeFtp::Server.new(21212)
+## 21212 is the control port, which is used by FTP for the primary connection
+## 21213 is the data port, used in FTP passive mode to send file contents
+server.start
+
+ftp = Net::FTP.new
+ftp.connect('127.0.0.1', 21212)
+ftp.login('user', 'password')
+ftp.passive = false
+ftp.put('some_file.txt')
+ftp.close
+
+expect(server.files).to include('some_file.txt')
+expect(server.file('some_file.txt').bytes).to eq 25
+expect(server.file('some_file.txt')).to be_active
+expect(server.file('some_file.txt')).to_not be_passive
+
+server.stop
+```
+
+Note that many FTP clients default to active, unless specified otherwise.
+
+## Caveats
+
+This is *not* a real FTP server and should not be treated as one. The goal of
+this gem is not to create a thread-safe multi-client implementation.  It is best
+used to unit test code that generates files and transfers them to an FTP server.
+
+As such, there are some things that won't be accepted upstream from pull
+requests:
+* simultaneous multi-client code
+* persistence support
+* binding to arbitrary IPs
+* global state beyond that required to pass the minimum required to
+  generate passing tests
+
+## Recommendations for testing patterns
+
+*Separate configuration from code.* Do not hard code the IP address, FQDN or
+port of an FTP server in your code. It introduces fragility into your tests.
+Also, the default FTP port of 21 is a privileged port, and should be avoided.
+
+*Separate the code that generates files from the code that uploads files.* You
+tests will run much more quickly if you only try to upload small files. If you
+have tests showing that you generate correct files from your data, then you can
+trust that. Why do you need to upload a 20M file in your tests if you can stub
+out your file generation method and test file upload against 10 bytes? Fast fast
+fast.
+
+## References
+
+* http://rubyforge.org/projects/ftpd/ - a simple ftp daemon written by Chris Wanstrath
+* http://ruby-doc.org/stdlib/libdoc/gserver/rdoc/index.html - a generic server in the Ruby standard library, by John W Small

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler'
+  require 'rspec/core/rake_task'
+  require 'rubocop/rake_task'
+rescue LoadError => e
+  warn e
+end
+
+Bundler::GemHelper.install_tasks if defined?(Bundler)
+RSpec::Core::RakeTask.new if defined?(RSpec)
+RuboCop::RakeTask.new if defined?(RuboCop)
+
+task default: %i[rubocop spec]

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/fake_ftp.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'fake_ftp/version'
+
+Gem::Specification.new do |s|
+  s.name = 'fake_ftp'
+  s.version = FakeFtp::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Colin Shield', 'Eric Saxby']
+  s.email = ['sax+github@livinginthepast.org']
+  s.homepage = 'http://rubygems.org/gems/fake_ftp'
+  s.summary = 'Creates a fake FTP server for use in testing'
+  s.description = 'Testing FTP? Use this!'
+  s.license = 'MIT'
+
+  s.files = `git ls-files -z`.split("\0")
+  s.test_files = `git ls-files -z -- spec/*`.split("\0")
+  s.require_paths = %w[lib]
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/lib/fake_ftp.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FakeFtp
+  autoload :Server, 'fake_ftp/server'
+  autoload :File, 'fake_ftp/file'
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/lib/fake_ftp/file.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FakeFtp
+  class File
+    attr_accessor :bytes, :data, :name, :last_modified_time
+    attr_writer :type
+    attr_reader :created
+
+    def initialize(name = nil, data = nil, type = nil,
+                   last_modified_time = Time.now)
+      @created = Time.now
+      @name = name
+      @data = data
+      # FIXME: this is far too ambiguous. args should not mean different
+      # things in different contexts.
+      data_is_bytes = (data.nil? || data.is_a?(Integer))
+      @bytes = data_is_bytes ? data : data.to_s.length
+      @data = data_is_bytes ? nil : data
+      @type = type
+      @last_modified_time = last_modified_time.utc
+    end
+
+    def basename
+      ::File.basename(@name)
+    end
+
+    def data=(data)
+      @data = data
+      @bytes = @data.nil? ? nil : data.length
+    end
+
+    def passive?
+      @type == :passive
+    end
+
+    def active?
+      @type == :active
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.3.0/lib/fake_ftp/server.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'thread'
+require 'timeout'
+
+module FakeFtp
+  class Server
+    attr_accessor :client, :command_state, :data_server, :passive_port
+    attr_accessor :port, :store, :workdir
+
+    alias path workdir
+
+    def initialize(control_port = 21, data_port = nil, options = {})
+      @port = control_port
+      @passive_port = data_port
+      @store = {}
+      @workdir = '/pub'
+      @options = options
+      @command_state = {}
+
+      @connection = nil
+      @data_server = nil
+      @server = nil
+      @client = nil
+
+      raise Errno::EADDRINUSE, port.to_s if !control_port.zero? && running?
+
+      if passive_port && !passive_port.zero? && running?(passive_port)
+        raise Errno::EADDRINUSE, passive_port.to_s
+      end
+
+      self.mode = options.fetch(:mode, :active)
+      self.absolute = options.fetch(:absolute, false)
+    end
+
+    def files
+      @store.values.map do |f|
+        if absolute?
+          abspath(f.name)
+        else
+          f.name
+        end
+      end
+    end
+
+    def file(name)
+      @store.values.detect do |f|
+        if absolute?
+          abspath(f.name) == name
+        else
+          f.name == name
+        end
+      end
+    end
+
+    def reset
+      @store.clear
+    end
+
+    def add_file(filename, data, last_modified_time = Time.now)
+      @store[abspath(filename)] = FakeFtp::File.new(
+        filename.to_s, data, options[:mode], last_modified_time
+      )
+    end
+
+    def start
+      @started = true
+      @server = ::TCPServer.new('127.0.0.1', port)
+      @port = @server.addr[1]
+      @thread = Thread.new do
+        while @started
+          debug('enter client loop')
+          @client = begin
+                      @server.accept
+                    rescue => e
+                      debug("error on accept: #{e}")
+                      nil
+                    end
+          next unless @client
+          respond_with('220 Can has FTP?')
+          @connection = Thread.new(@client) do |socket|
+            debug('enter request thread')
+            while @started && !socket.nil? && !socket.closed?
+              input = begin
+                        socket.gets
+                      rescue
+                        debug("error on socket.gets: #{e}")
+                        nil
+                      end
+              if input
+                debug("server client raw: <- #{input.inspect}")
+                respond_with(handle_request(input))
+              end
+            end
+            unless @client.nil?
+              @client.close unless @client.closed?
+              @client = nil
+            end
+            debug('leave request thread')
+          end
+          debug('leave client loop')
+        end
+        unless @server.nil?
+          @server.close unless @server.closed?
+          @server = nil
+        end
+      end
+
+      return unless passive_port
+      @data_server = ::TCPServer.new('127.0.0.1', passive_port)
+      @passive_port = @data_server.addr[1]
+    end
+
+    def stop
+      @started = false
+      @client&.close
+      @server&.close
+      @server = nil
+      @data_server&.close
+      @data_server = nil
+    end
+
+    def running?(tcp_port = nil)
+      return port_is_open?(port) if tcp_port.nil?
+      port_is_open?(tcp_port)
+    end
+
+    alias is_running? running?
+
+    def mode=(value)
+      unless %i[active passive].include?(value)
+        raise ArgumentError, "invalid mode #{value.inspect}"
+      end
+      options[:mode] = value
+    end
+
+    def mode
+      options[:mode]
+    end
+
+    def absolute?
+      options[:absolute]
+    end
+
+    def absolute=(value)
+      unless [true, false].include?(value)
+        raise ArgumentError, "invalid absolute #{value}"
+      end
+      options[:absolute] = value
+    end
+
+    attr_reader :options
+    private :options
+
+    def abspath(filename)
+      return filename if filename.start_with?('/')
+      [@workdir.to_s, filename].join('/').gsub('//', '/')
+    end
+
+    def respond_with(stuff)
+      return if stuff.nil? || @client.nil? || @client.closed?
+      debug("server client raw: -> #{stuff.inspect}")
+      @client.print(stuff + "\r\n")
+    end
+
+    private def handle_request(request)
+      return if request.nil?
+      debug("raw request: #{request.inspect}")
+      command = request[0, 4].downcase.strip
+      contents = request.split
+      message = contents[1..contents.length]
+
+      inst = load_command_instance(command)
+      return "500 Unknown command #{command.inspect}" if inst.nil?
+      debug(
+        "running command #{command.inspect} " \
+        "#{inst.class.name}#run(*#{message.inspect})"
+      )
+      inst.run(*([self] + message))
+    end
+
+    private def load_command_instance(command)
+      require "fake_ftp/server_commands/#{command}"
+      FakeFtp::ServerCommands.constants.each do |const_name|
+        next unless const_name.to_s.downcase == command
+        return FakeFtp::ServerCommands.const_get(const_name).new
+      end
+      nil
+    rescue LoadError => e
+      debug("failed to require #{command.inspect} class: #{e}")
+      nil
+    end
+
+    def active?
+      options[:mode] == :active
+    end
+
+    private def port_is_open?(port)
+      begin
+        Timeout.timeout(1) do
+          begin
+            TCPSocket.new('127.0.0.1', port).close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue Timeout::Error => e
+        debug("timeout while checking port #{port}: #{e}")
+      end
+
+      false
+    end
+
+    def build_wildcards(args)
+      wildcards = []
+      args.each do |arg|
+        next unless arg.include? '*'
+        wildcards << arg.gsub('*', '.*')
+      end
+      wildcards
+    end
+
+    def matching_files(wildcards)
+      if !wildcards.empty?
+        @store.values.select do |f|
+          wildcards.any? { |wildcard| f.name =~ /#{wildcard}/ }
+        end
+      else
+        @store.values
+      end
+    end
+
+    def debug(msg)
+      return unless options[:debug]
+      $stderr.puts("DEBUG:fake_ftp:#{msg}")
+    end
+  end
+end