vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/spec/integration/server_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-require 'net/ftp'
-
-describe FakeFtp::Server, 'with ftp client' do
-  let(:server) { FakeFtp::Server.new(21212, 21213) }
-  let(:client) { Net::FTP.new }
-  let(:text_filename) { File.expand_path("../fixtures/text_file.txt", File.dirname(__FILE__)) }
-
-  before { server.start }
-
-  after :each do
-    client.close
-    server.stop
-  end
-
-  it 'should accept connections' do
-    expect { client.connect('127.0.0.1', 21212) }.to_not raise_error
-  end
-
-  context "with client" do
-    before { client.connect("127.0.0.1", 21212) }
-
-    it "should allow anonymous authentication" do
-      expect { client.login }.to_not raise_error
-    end
-
-    it "should allow named authentication" do
-      expect { client.login('someone', 'password') }.to_not raise_error
-    end
-
-    it "should allow client to quit" do
-      expect { client.login('someone', 'password') }.to_not raise_error
-      expect { client.quit }.to_not raise_error
-    end
-
-    it "should allow mtime" do
-      filename = 'someone'
-      time = Time.now
-      server.add_file(filename, "some data", time)
-
-      client.passive = false
-      mtime = client.mtime(filename)
-      expect(mtime.to_s).to eql(time.to_s)
-
-      client.passive = true
-      mtime = client.mtime(filename)
-      expect(mtime.to_s).to eql(time.to_s)
-    end
-
-    it "should put files using PASV" do
-      expect(File.stat(text_filename).size).to eql(20)
-
-      client.passive = true
-      expect { client.put(text_filename) }.to_not raise_error
-
-      expect(server.files).to include('text_file.txt')
-      expect(server.file('text_file.txt').bytes).to eql(20)
-      expect(server.file('text_file.txt')).to be_passive
-      expect(server.file('text_file.txt')).to_not be_active
-    end
-
-    it "should put files using active" do
-      expect(File.stat(text_filename).size).to eql(20)
-
-      client.passive = false
-      expect { client.put(text_filename) }.to_not raise_error
-
-      expect(server.files).to include('text_file.txt')
-      expect(server.file('text_file.txt').bytes).to eql(20)
-      expect(server.file('text_file.txt')).to_not be_passive
-      expect(server.file('text_file.txt')).to be_active
-    end
-
-    xit "should disconnect clients on close" do
-      # TODO: when this succeeds, we can care less about manually closing clients
-      #       otherwise we get a CLOSE_WAIT process hanging around that blocks our port
-      server.stop
-      expect(client.closed?).to be_true
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/spec/models/fake_ftp/file_spec.rb

@@ -1,102 +0,0 @@
-require "spec_helper.rb"
-
-describe FakeFtp::File do
-  context 'attributes' do
-    before :each do
-      @file = FakeFtp::File.new
-    end
-
-    it "has a name attribute" do
-      @file.name = "some name"
-      expect(@file.name).to eql("some name")
-    end
-
-    it "has a last_modified_time attribute" do
-      now = Time.now
-      @file.last_modified_time = now
-      expect(@file.last_modified_time).to eql(now)
-    end
-
-    it "has a bytes attribute" do
-      @file.bytes = 87
-      expect(@file.bytes).to eql(87)
-    end
-
-    it "has a data attribute" do
-      @file.data = 'some data'
-      expect(@file.data).to eql('some data')
-      expect(@file.bytes).to eql('some data'.length)
-    end
-  end
-
-  context 'setup' do
-    it "can be initialized without attributes" do
-      file = FakeFtp::File.new
-      expect(file.name).to be_nil
-      expect(file.bytes).to be_nil
-      expect(file.instance_variable_get(:@type)).to be_nil
-    end
-
-    it "can be initialized with name" do
-      file = FakeFtp::File.new('filename')
-      expect(file.name).to eql('filename')
-      expect(file.bytes).to be_nil
-      expect(file.instance_variable_get(:@type)).to be_nil
-    end
-
-    it "can be initialized with name and bytes" do
-      file = FakeFtp::File.new('filename', 104)
-      expect(file.name).to eql('filename')
-      expect(file.bytes).to eql(104)
-      expect(file.instance_variable_get(:@type)).to be_nil
-    end
-
-    it "can be initialized with name and bytes and type" do
-      file = FakeFtp::File.new('filename', 104, :passive)
-      expect(file.name).to eql('filename')
-      expect(file.bytes).to eql(104)
-      expect(file.instance_variable_get(:@type)).to eql(:passive)
-    end
-
-    it "can be initialized with name and bytes and type and last_modified_time" do
-      time = Time.now
-      file = FakeFtp::File.new('filename', 104, :passive, time)
-      expect(file.name).to eql('filename')
-      expect(file.bytes).to eql(104)
-      expect(file.instance_variable_get(:@type)).to eql(:passive)
-      expect(file.last_modified_time).to eql(time)
-    end
-  end
-
-  describe '#passive?' do
-    before :each do
-      @file = FakeFtp::File.new
-    end
-
-    it "should be true if type is :passive" do
-      @file.type = :passive
-      expect(@file.passive?).to be_true
-    end
-
-    it "should be false if type is :active" do
-      @file.type = :active
-      expect(@file.passive?).to be_false
-    end
-  end
-
-  describe '#active?' do
-    before :each do
-      @file = FakeFtp::File.new
-    end
-
-    it "should be true if type is :active" do
-      @file.type = :active
-      expect(@file.active?).to be_true
-    end
-
-    it "should be false if type is :passive" do
-      @file.type = :passive
-      expect(@file.active?).to be_false
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/spec/models/fake_ftp/server_spec.rb

@@ -1,76 +0,0 @@
-require "spec_helper.rb"
-
-describe FakeFtp::Server, 'setup' do
-  it "starts a server on port n" do
-    server = FakeFtp::Server.new(21212)
-    expect(server.port).to eql(21212)
-  end
-
-  it "should defaults to port 21" do
-    server = FakeFtp::Server.new
-    expect(server.port).to eql(21)
-  end
-
-  it "starts a passive server on port p" do
-    server = FakeFtp::Server.new(21212, 21213)
-    expect(server.passive_port).to eql(21213)
-  end
-
-  it "should start and stop" do
-    server = FakeFtp::Server.new(21212)
-    expect(server.is_running?).to be_false
-    server.start
-    expect(server.is_running?).to be_true
-    server.stop
-    expect(server.is_running?).to be_false
-  end
-
-  it "should default :mode to :active" do
-    server = FakeFtp::Server.new(21212, 21213)
-    expect(server.mode).to eql(:active)
-  end
-
-  it "should start and stop passive port" do
-    server = FakeFtp::Server.new(21212, 21213)
-    expect(server.is_running?(21213)).to be_false
-    server.start
-    expect(server.is_running?(21213)).to be_true
-    server.stop
-    expect(server.is_running?(21213)).to be_false
-  end
-
-  it "should raise if attempting to use a bound port" do
-    server = FakeFtp::Server.new(21212)
-    server.start
-    expect { FakeFtp::Server.new(21212) }.to raise_error(Errno::EADDRINUSE, "Address already in use - 21212")
-    server.stop
-  end
-
-  it "should raise if attempting to use a bound passive_port" do
-    server = FakeFtp::Server.new(21212, 21213)
-    server.start
-    expect { FakeFtp::Server.new(21214, 21213) }.to raise_error(Errno::EADDRINUSE, "Address already in use - 21213")
-    server.stop
-  end
-end
-
-describe FakeFtp::Server, 'files' do
-  let(:file) { FakeFtp::File.new('filename', 34) }
-  let(:server) { FakeFtp::Server.new(21212) }
-
-  before { server.instance_variable_set(:@files, [file]) }
-
-  it "returns filenames from :files" do
-    expect(server.files).to include('filename')
-  end
-
-  it "can be accessed with :file" do
-    expect(server.file('filename')).to eql(file)
-  end
-
-  it "can reset files" do
-    server.reset
-    expect(server.files).to eql([])
-  end
-end
-

data/vendor/bundle/ruby/2.4.0/gems/fake_ftp-0.1.1/spec/spec_helper.rb

@@ -1,18 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.dirname(__FILE__), '**','*')
-
-require 'rubygems'
-require 'bundler/setup'
-
-require 'rspec'
-require 'fake_ftp' # and any other gems you need
-
-RSpec.configure do |config|
-  
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-end

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.4/Gemfile

@@ -1,6 +0,0 @@
-source "http://rubygems.org"
-gemspec
-
-group :test do
-  gem 'rake', '< 11'
-end

data/vendor/bundle/ruby/2.4.0/gems/hashdiff-0.3.4/README.md

@@ -1,207 +0,0 @@
-# HashDiff [![Build Status](https://secure.travis-ci.org/liufengyun/hashdiff.png)](http://travis-ci.org/liufengyun/hashdiff) [![Gem Version](https://badge.fury.io/rb/hashdiff.png)](http://badge.fury.io/rb/hashdiff)
-
-HashDiff is a ruby library to compute the smallest difference between two hashes.
-
-It also supports comparing two arrays.
-
-HashDiff does not monkey-patch any existing class. All features are contained inside the `HashDiff` module.
-
-**Docs**: [Documentation](http://rubydoc.info/gems/hashdiff)
-
-## Why HashDiff?
-
-Given two Hashes A and B, sometimes you face the question: what's the smallest modification that can be made to change A into B?
-
-An algorithm that responds to this question has to do following:
-
-* Generate a list of additions, deletions and changes, so that `A + ChangeSet = B` and `B - ChangeSet = A`.
-* Compute recursively -- Arrays and Hashes may be nested arbitrarily in A or B.
-* Compute the smallest change -- it should recognize similar child Hashes or child Arrays between A and B.
-
-HashDiff answers the question above using an opinionated approach:
-
-* Hash can be represented as a list of (dot-syntax-path, value) pairs. For example, `{a:[{c:2}]}` can be represented as `["a[0].c", 2]`.
-* The change set can be represented using the dot-syntax representation. For example, `[['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]`.
-* It compares Arrays using the [LCS(longest common subsequence)](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem) algorithm.
-* It recognizes similar Hashes in an Array using a similarity value (0 < similarity <= 1).
-
-## Usage
-
-To use the gem, add the following to your Gemfile:
-
-```ruby
-gem 'hashdiff'
-```
-
-## Quick Start
-
-### Diff
-
-Two simple hashes:
-
-```ruby
-a = {a:3, b:2}
-b = {}
-
-diff = HashDiff.diff(a, b)
-diff.should == [['-', 'a', 3], ['-', 'b', 2]]
-```
-
-More complex hashes:
-
-```ruby
-a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
-b = {a:{y:3}, b:{y:3, z:30}}
-
-diff = HashDiff.diff(a, b)
-diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
-```
-
-Arrays in hashes:
-
-```ruby
-a = {a:[{x:2, y:3, z:4}, {x:11, y:22, z:33}], b:{x:3, z:45}}
-b = {a:[{y:3}, {x:11, z:33}], b:{y:22}}
-
-diff = HashDiff.best_diff(a, b)
-diff.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
-```
-
-### Patch
-
-patch example:
-
-```ruby
-a = {a: 3}
-b = {a: {a1: 1, a2: 2}}
-
-diff = HashDiff.diff(a, b)
-HashDiff.patch!(a, diff).should == b
-```
-
-unpatch example:
-
-```ruby
-a = [{a: 1, b: 2, c: 3, d: 4, e: 5}, {x: 5, y: 6, z: 3}, 1]
-b = [1, {a: 1, b: 2, c: 3, e: 5}]
-
-diff = HashDiff.diff(a, b) # diff two array is OK
-HashDiff.unpatch!(b, diff).should == a
-```
-
-### Options
-
-There are six options available: `:delimiter`, `:similarity`,
-`:strict`, `:numeric_tolerance`, `:strip` and `:case_insensitive`.
-
-#### `:delimiter`
-
-You can specify `:delimiter` to be something other than the default dot. For example:
-
-```ruby
-a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
-b = {a:{y:3}, b:{y:3, z:30}}
-
-diff = HashDiff.diff(a, b, :delimiter => '\t')
-diff.should == [['-', 'a\tx', 2], ['-', 'a\tz', 4], ['-', 'b\tx', 3], ['~', 'b\tz', 45, 30], ['+', 'b\ty', 3]]
-```
-
-#### `:similarity`
-
-In cases where you have similar hash objects in arrays, you can pass a custom value for `:similarity` instead of the default `0.8`.  This is interpreted as a ratio of similarity (default is 80% similar, whereas `:similarity => 0.5` would look for at least a 50% similarity).
-
-#### `:strict`
-
-The `:strict` option, which defaults to `true`, specifies whether numeric types are compared on type as well as value.  By default, a Fixnum will never be equal to a Float (e.g. 4 != 4.0).  Setting `:strict` to false makes the comparison looser (e.g. 4 == 4.0).
-
-#### `:numeric_tolerance`
-
-The :numeric_tolerance option allows for a small numeric tolerance.
-
-```ruby
-a = {x:5, y:3.75, z:7}
-b = {x:6, y:3.76, z:7}
-
-diff = HashDiff.diff(a, b, :numeric_tolerance => 0.1)
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### `:strip`
-
-The :strip option strips all strings before comparing.
-
-```ruby
-a = {x:5, s:'foo '}
-b = {x:6, s:'foo'}
-
-diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :strip => true })
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### `:case_insensitive`
-
-The :case_insensitive option makes string comparisions ignore case.
-
-```ruby
-a = {x:5, s:'FooBar'}
-b = {x:6, s:'foobar'}
-
-diff = HashDiff.diff(a, b, :comparison => { :numeric_tolerance => 0.1, :case_insensitive => true })
-diff.should == [["~", "x", 5, 6]]
-```
-
-#### Specifying a custom comparison method
-
-It's possible to specify how the values of a key should be compared.
-
-```ruby
-a = {a:'car', b:'boat', c:'plane'}
-b = {a:'bus', b:'truck', c:' plan'}
-
-diff = HashDiff.diff(a, b) do |path, obj1, obj2|
-  case path
-  when  /a|b|c/
-    obj1.length == obj2.length
-  end
-end
-
-diff.should == [['~', 'b', 'boat', 'truck']]
-```
-
-The yielded params of the comparison block is `|path, obj1, obj2|`, in which path is the key (or delimited compound key) to the value being compared. When comparing elements in array, the path is with the format `array[*]`. For example:
-
-```ruby
-a = {a:'car', b:['boat', 'plane'] }
-b = {a:'bus', b:['truck', ' plan'] }
-
-diff = HashDiff.diff(a, b) do |path, obj1, obj2|
-  case path
-  when 'b[*]'
-    obj1.length == obj2.length
-  end
-end
-
-diff.should == [["~", "a", "car", "bus"], ["~", "b[1]", "plane", " plan"], ["-", "b[0]", "boat"], ["+", "b[0]", "truck"]]
-```
-
-When a comparison block is given, it'll be given priority over other specified options. If the block returns value other than `true` or `false`, then the two values will be compared with other specified options.
-
-#### Sorting arrays before comparison
-
-An order difference alone between two arrays can create too many diffs to be useful. Consider sorting them prior to diffing.
-
-```ruby
-a = {a:'car', b:['boat', 'plane'] }
-b = {a:'car', b:['plane', 'boat'] }
-
-HashDiff.diff(a, b) => [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
-
-b[:b].sort!
-
-HashDiff.diff(a, b) => []
-```
-
-## License
-
-HashDiff is distributed under the MIT-LICENSE.
-