vagrant-unbundled 2.1.4.0 → 2.2.0.0

data/vendor/bundle/ruby/2.5.0/gems/winrm-fs-1.3.1/spec/integration/file_manager_spec.rb

@@ -0,0 +1,303 @@
+require 'pathname'
+
+# rubocop:disable BlockLength
+describe WinRM::FS::FileManager do
+  let(:upload_dir) { "winrm_#{rand(2**16)}" }
+  let(:dest_dir) { File.join(subject.temp_dir, upload_dir) }
+  let(:temp_upload_dir) { '$env:TEMP/winrm-upload' }
+  let(:spec_dir) { File.expand_path(File.dirname(File.dirname(__FILE__))) }
+  let(:this_file) { Pathname.new(__FILE__) }
+  let(:service) { winrm_connection }
+
+  subject { WinRM::FS::FileManager.new(service) }
+
+  before(:each) do
+    expect(subject.delete(dest_dir)).to be true
+    expect(subject.delete(temp_upload_dir)).to be true
+  end
+
+  context 'exists?' do
+    it 'should exist' do
+      expect(subject.exists?('c:/windows')).to be true
+      expect(subject.exists?('c:/foobar')).to be false
+    end
+  end
+
+  context 'create and delete dir' do
+    it 'should create the directory recursively' do
+      subdir = File.join(dest_dir, 'subdir1', 'subdir2')
+      expect(subject.create_dir(subdir)).to be true
+      expect(subject.exists?(subdir)).to be true
+      expect(subject.create_dir(subdir)).to be true
+      expect(subject.delete(subdir)).to be true
+      expect(subject.exists?(subdir)).to be false
+    end
+  end
+
+  context 'temp_dir' do
+    it 'should return the remote users temp dir' do
+      expect(subject.temp_dir).to match(%r{C:/Users/\S+/AppData/Local/Temp})
+    end
+  end
+
+  context 'download file' do
+    let(:download_dir) { File.join(spec_dir, 'temp') }
+    let(:dest_file) { Pathname.new(File.join(dest_dir, File.basename(this_file))) }
+    let(:download_file) { Pathname.new(File.join(download_dir, File.basename(this_file))) }
+
+    before(:each) do
+      expect(subject.delete(dest_dir)).to be true
+      FileUtils.rm_rf(Dir.glob("#{download_dir}/*"))
+      FileUtils.mkdir_p(download_dir)
+    end
+
+    it 'should download the specified file' do
+      subject.upload(this_file, dest_file)
+      subject.download(dest_file, download_file)
+      expect(File.open(download_file).read).to eq(File.open(this_file).read)
+    end
+  end
+
+  context 'download file chunked' do
+    let(:download_dir) { File.join(spec_dir, 'temp') }
+    let(:dest_file) { Pathname.new(File.join(dest_dir, File.basename(this_file))) }
+    let(:download_file) { Pathname.new(File.join(download_dir, File.basename(this_file))) }
+
+    before(:each) do
+      expect(subject.delete(dest_dir)).to be true
+      FileUtils.rm_rf(Dir.glob("#{download_dir}/*"))
+      FileUtils.mkdir_p(download_dir)
+    end
+
+    it 'should download the specified file in 1000 byte chunks' do
+      subject.upload(this_file, dest_file)
+      subject.download(dest_file, download_file, 1000)
+      expect(File.open(download_file).read).to eq(File.open(this_file).read)
+    end
+  end
+
+  context 'download directory' do
+    let(:download_dir) { File.join(spec_dir, 'temp') }
+    let(:dest_file) { Pathname.new(File.join(dest_dir, File.basename(this_file))) }
+    let(:root_dir) { File.expand_path('../../', File.dirname(__FILE__)) }
+    let(:winrm_fs_dir) { File.join(root_dir, 'lib/winrm-fs') }
+
+    before(:each) do
+      expect(subject.delete(dest_dir)).to be true
+      FileUtils.rm_rf(Dir.glob("#{download_dir}/*"))
+      FileUtils.mkdir_p(download_dir)
+    end
+
+    it 'downloads the directory contents recursively' do
+      subject.upload(winrm_fs_dir, dest_dir)
+      subject.download(dest_dir, download_dir)
+
+      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
+        host_file_rel = Pathname.new(host_file).relative_path_from(
+          Pathname.new(winrm_fs_dir)
+        ).to_s
+        download_file = File.join(download_dir, upload_dir, host_file_rel)
+        expect(File.open(download_file).read).to eq(File.open(host_file).read)
+      end
+    end
+  end
+
+  context 'upload file' do
+    let(:dest_file) { Pathname.new(File.join(dest_dir, File.basename(this_file))) }
+    let(:from_memory) { StringIO.new('Upload From Memory') }
+
+    before(:each) do
+      expect(subject.delete(dest_dir)).to be true
+    end
+
+    it 'should upload a single StringIO object to a remote file' do
+      subject.upload(from_memory, dest_file)
+      expect(subject).to have_created(dest_file).with_content(from_memory.string)
+    end
+
+    it 'should error if multiple StringIO objects passed to upload' do
+      expect { subject.upload([from_memory, from_memory], dest_file) }
+        .to raise_error(WinRM::FS::Core::UploadSourceError)
+    end
+
+    it 'should error if both a StringIO object and a file path passed to upload' do
+      expect { subject.upload([from_memory, this_file], dest_file) }
+        .to raise_error(WinRM::FS::Core::UploadSourceError)
+    end
+
+    it 'should upload the specified file' do
+      subject.upload(this_file, dest_file)
+      expect(subject).to have_created(dest_file).with_content(this_file)
+    end
+
+    it 'should upload to root of the c: drive' do
+      subject.upload(this_file, 'c:/winrmtest.rb')
+      expect(subject).to have_created('c:/winrmtest.rb').with_content(this_file)
+      subject.delete('c:/winrmtest.rb')
+    end
+
+    it 'should upload just filename' do
+      subject.upload(this_file, 'winrmtest.rb')
+      expect(subject).to have_created('winrmtest.rb').with_content(this_file)
+      subject.delete('winrmtest.rb')
+    end
+
+    it 'should upload using relative file path' do
+      subject.upload('./spec/integration/file_manager_spec.rb', dest_file)
+      expect(subject).to have_created(dest_file).with_content(this_file)
+    end
+
+    it 'should upload to the specified directory' do
+      subject.create_dir(dest_dir)
+      subject.upload(this_file, dest_dir)
+      expect(subject).to have_created(dest_file).with_content(this_file)
+    end
+
+    it 'should treat extensionless target as file if not an existing directory' do
+      subject.upload(this_file, dest_dir)
+      expect(subject).to have_created(dest_dir).with_content(this_file)
+    end
+
+    it 'should create extensionless source under target dir if target dir exists' do
+      subject.create_dir(dest_dir)
+      src_file = File.expand_path('../../Gemfile', File.dirname(__FILE__))
+      subject.upload(src_file, dest_dir)
+      expect(subject).to have_created(File.join(dest_dir, 'Gemfile')).with_content(src_file)
+    end
+
+    it 'should upload to the specified directory with env var' do
+      subject.upload(this_file, '$env:Temp')
+      expected_dest_file = File.join(subject.temp_dir, File.basename(this_file))
+      expect(subject).to have_created(expected_dest_file).with_content(this_file)
+    end
+
+    it 'should upload to Program Files sub dir' do
+      subject.create_dir('$env:ProgramFiles/foo')
+      subject.upload(this_file, '$env:ProgramFiles/foo')
+      expect(subject).to have_created('c:/Program Files/foo/file_manager_spec.rb') \
+        .with_content(this_file)
+    end
+
+    it 'should upload to the specified nested directory' do
+      dest_sub_dir = File.join(dest_dir, 'subdir')
+      subject.create_dir(dest_sub_dir)
+      dest_sub_dir_file = File.join(dest_sub_dir, File.basename(this_file))
+      subject.upload(this_file, dest_sub_dir)
+      expect(subject).to have_created(dest_sub_dir_file).with_content(this_file)
+    end
+
+    it 'yields progress data' do
+      block_called = false
+      total_bytes_copied = 0
+      total = subject.upload(this_file, dest_file) do |bytes_copied, total_bytes, local_path, remote_path|
+        expect(total_bytes).to be > 0
+        total_bytes_copied = bytes_copied
+        expect(local_path).to eq(this_file.to_s)
+        expect(remote_path).to eq(dest_file.to_s)
+        block_called = true
+      end
+      expect(total_bytes_copied).to eq(total)
+      expect(block_called).to be true
+      expect(total).to be > 0
+    end
+
+    it 'should not upload when content matches' do
+      subject.upload(this_file, dest_dir)
+      bytes_uploaded = subject.upload(this_file, dest_dir)
+      expect(bytes_uploaded).to eq 0
+    end
+
+    it 'should upload when content differs' do
+      matchers_file = File.join(spec_dir, 'matchers.rb')
+      subject.upload(matchers_file, dest_file)
+      bytes_uploaded = subject.upload(this_file, dest_file)
+      expect(bytes_uploaded).to be > 0
+    end
+
+    it 'raises WinRMUploadError when a bad source path is specified' do
+      expect { subject.upload('c:/some/non-existant/path/foo', dest_file) }.to raise_error
+    end
+  end
+
+  context 'upload empty file' do
+    let(:empty_src_file) { Tempfile.new('empty') }
+    let(:dest_file) { File.join(dest_dir, 'emptyfile.txt') }
+
+    it 'creates a new empty file' do
+      expect(subject.upload(empty_src_file.path, dest_file)).to be 0
+      expect(subject).to have_created(dest_file).with_content('')
+    end
+
+    it 'overwrites an existing file' do
+      expect(subject.upload(this_file, dest_file)).to be > 0
+      expect(subject.upload(empty_src_file.path, dest_file)).to be 0
+      expect(subject).to have_created(dest_file).with_content('')
+    end
+  end
+
+  context 'upload directory' do
+    let(:root_dir) { File.expand_path('../../', File.dirname(__FILE__)) }
+    let(:winrm_fs_dir) { File.join(root_dir, 'lib/winrm-fs') }
+    let(:core_dir) { File.join(root_dir, 'lib/winrm-fs/core') }
+    let(:scripts_dir) { File.join(root_dir, 'lib/winrm-fs/scripts') }
+
+    it 'copies the directory contents recursively when directory does not exist' do
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+
+      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
+        host_file_rel = Pathname.new(host_file).relative_path_from(
+          Pathname.new(winrm_fs_dir)
+        ).to_s
+        remote_file = File.join(dest_dir, host_file_rel)
+        expect(subject).to have_created(remote_file).with_content(host_file)
+      end
+    end
+
+    it 'copies the directory recursively when directory does exist' do
+      subject.create_dir(dest_dir)
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+
+      Dir.glob(winrm_fs_dir + '/**/*.rb').each do |host_file|
+        host_file_rel = Pathname.new(host_file).relative_path_from(
+          Pathname.new(winrm_fs_dir).dirname
+        ).to_s
+        remote_file = File.join(dest_dir, host_file_rel)
+        expect(subject).to have_created(remote_file).with_content(host_file)
+      end
+    end
+
+    it 'does not copy the directory when content is the same' do
+      subject.upload(winrm_fs_dir, dest_dir)
+      bytes_uploaded = subject.upload(winrm_fs_dir, dest_dir)
+      expect(bytes_uploaded).to eq 0
+    end
+
+    it 'unzips the directory when cached content is the same' do
+      subject.upload(winrm_fs_dir, dest_dir)
+      subject.delete(dest_dir)
+      expect(subject.exists?(dest_dir)).to be false
+      subject.upload(winrm_fs_dir, dest_dir)
+      expect(subject.exists?(dest_dir)).to be true
+    end
+
+    it 'unzips multiple directories when cached content is the same for all' do
+      subject.create_dir(dest_dir)
+      subject.upload([core_dir, scripts_dir], dest_dir)
+      subject.delete(dest_dir)
+      expect(subject.exists?(dest_dir)).to be false
+      subject.create_dir(dest_dir)
+      subject.upload([core_dir, scripts_dir], dest_dir)
+      expect(subject.exists?(File.join(dest_dir, 'core'))).to be true
+      expect(subject.exists?(File.join(dest_dir, 'scripts'))).to be true
+    end
+
+    it 'copies the directory when content differs' do
+      subject.upload(winrm_fs_dir, dest_dir)
+      bytes_uploaded = subject.upload(core_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+    end
+  end
+end
+# rubocop:enable BlockLength

data/vendor/bundle/ruby/2.5.0/gems/winrm-fs-1.3.1/spec/integration/tmp_zip_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../../lib/winrm-fs/core/tmp_zip'
+
+describe WinRM::FS::Core::TmpZip do
+  let(:winrm_fs_dir) { File.expand_path('../../lib/winrm-fs', File.dirname(__FILE__)) }
+
+  subject { WinRM::FS::Core::TmpZip.new(winrm_fs_dir) }
+
+  context 'temp file creation' do
+    it 'should create a temp file on disk' do
+      path = subject.path
+      expect(File.exist?(path)).to be true
+      subject.unlink
+      expect(File.exist?(path)).to be false
+    end
+  end
+
+  context 'create zip' do
+    it 'should add all files in directory to the zip recursively' do
+      expect(subject).to contain_zip_entries([
+                                               'exceptions.rb',
+                                               'core/tmp_zip.rb',
+                                               'scripts/checksum.ps1.erb'
+                                             ])
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-fs-1.3.1/spec/matchers.rb

@@ -0,0 +1,57 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :have_created do |remote_file|
+  match do |file_manager|
+    if @expected_content
+      downloaded_file = Tempfile.new('downloaded')
+      downloaded_file.close
+
+      subject.download(remote_file, downloaded_file.path)
+      @actual_content = File.read(downloaded_file.path)
+      downloaded_file.delete
+
+      file_manager.exists?(remote_file) && \
+        @actual_content == @expected_content
+    else
+      file_manager.exists?(remote_file)
+    end
+  end
+  chain :with_content do |expected_content|
+    expected_content = File.read(expected_content) if File.file?(expected_content)
+    @expected_content = expected_content
+  end
+  failure_message do
+    if @expected_content
+      <<-EOH
+Expected file '#{remote_file}' to exist with content:
+
+#{@expected_content}
+
+but instead got content:
+
+#{@actual_content}
+      EOH
+    else
+      "Expected file '#{remote_file}' to exist"
+    end
+  end
+end
+
+RSpec::Matchers.define :contain_zip_entries do |zip_entries|
+  match do |temp_zip_file|
+    zip_entries = [zip_entries] if zip_entries.is_a? String
+    @zip_file = Zip::File.open(temp_zip_file.path)
+    @missing_entries = []
+    zip_entries.each do |entry|
+      @missing_entries << entry unless @zip_file.find_entry(entry)
+    end
+    @missing_entries.empty?
+  end
+  failure_message do |temp_zip_file|
+    msg = "Expected #{temp_zip_file.path} to contain zip entries: #{@missing_entries}\n Got: "
+    @zip_file.each do |entry|
+      msg << entry.name << ', '
+    end
+    msg
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-fs-1.3.1/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'winrm-fs'
+require 'json'
+require_relative 'matchers'
+
+# Creates a WinRM connection for integration tests
+module ConnectionHelper
+  def winrm_connection
+    WinRM::Connection.new(config)
+  end
+
+  def config
+    @config ||= begin
+      cfg = symbolize_keys(YAML.safe_load(File.read(winrm_config_path)))
+      cfg[:basic_auth_only] = true unless cfg[:transport].eql? :kerberos
+      merge_environment!(cfg)
+      cfg
+    end
+  end
+
+  def merge_environment!(config)
+    merge_config_option_from_environment(config, 'user')
+    merge_config_option_from_environment(config, 'password')
+    merge_config_option_from_environment(config, 'no_ssl_peer_verification')
+    config[:options][:ssl_peer_fingerprint] = ENV['winrm_cert'] if ENV['use_ssl_peer_fingerprint']
+    config[:endpoint] = ENV['winrm_endpoint'] if ENV['winrm_endpoint']
+    config[:transport] = ENV['winrm_transport'] if ENV['winrm_transport']
+  end
+
+  def merge_config_option_from_environment(config, key)
+    env_key = 'winrm_' + key
+    config[key.to_sym] = ENV[env_key] if ENV[env_key]
+  end
+
+  def winrm_config_path
+    # Copy config-example.yml to config.yml and edit for your local configuration
+    path = File.expand_path("#{File.dirname(__FILE__)}/config.yml")
+    unless File.exist?(path)
+      # user hasn't done this, so use sane defaults for unit tests
+      path = File.expand_path("#{File.dirname(__FILE__)}/config-example.yml")
+    end
+    path
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def symbolize_keys(hash)
+    hash.each_with_object({}) do |(key, value), result|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  else value
+                  end
+      result[new_key] = new_value
+      result
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+end
+
+RSpec.configure do |config|
+  config.include(ConnectionHelper)
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-fs-1.3.1/spec/unit/tmp_zip_spec.rb

@@ -0,0 +1,78 @@
+#
+# Author:: Fletcher (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2015, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'winrm-fs/core/tmp_zip'
+
+describe WinRM::FS::Core::TmpZip do
+  let(:src_dir) do
+    tmpdir = Pathname.new(Dir.mktmpdir)
+    @tmpdirs << tmpdir
+    src_dir = tmpdir.join('src')
+    sub_dir = src_dir.join('veggies')
+
+    src_dir.mkpath
+    create_local_file(src_dir.join('apple.txt'), 'appleapple')
+    create_local_file(src_dir.join('banana.txt'), 'bananabanana')
+    create_local_file(src_dir.join('cherry.txt'), 'cherrycherry')
+    sub_dir.mkpath
+    create_local_file(sub_dir.join('carrot.txt'), 'carrotcarrot')
+    src_dir
+  end
+
+  let(:tmp_zip) { WinRM::FS::Core::TmpZip.new(src_dir) }
+
+  before { @tmpdirs = [] }
+
+  after do
+    @tmpdirs.each(&:rmtree)
+    tmp_zip.unlink if tmp_zip.path
+  end
+
+  it '#path returns path to created zip file' do
+    expect(tmp_zip.path.file?).to eq true
+  end
+
+  it '#unlink removes the file' do
+    path = tmp_zip.path
+    expect(path.file?).to eq true
+
+    tmp_zip.unlink
+
+    expect(path.file?).to eq false
+    expect(tmp_zip.path).to eq nil
+  end
+
+  describe 'for a zip file containing the base directory' do
+    let(:tmp_zip) { WinRM::FS::Core::TmpZip.new(src_dir) }
+
+    it 'contains the input entries' do
+      zip = Zip::File.new(tmp_zip.path)
+
+      expect(zip.map(&:name).sort).to eq(
+        ['apple.txt', 'banana.txt', 'cherry.txt', 'veggies/carrot.txt']
+      )
+      expect(zip.read('apple.txt')).to eq 'appleapple'
+      expect(zip.read('banana.txt')).to eq 'bananabanana'
+      expect(zip.read('cherry.txt')).to eq 'cherrycherry'
+      expect(zip.read('veggies/carrot.txt')).to eq 'carrotcarrot'
+    end
+  end
+
+  def create_local_file(path, content)
+    path.open('wb') { |file| file.write(content) }
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-fs-1.3.1/winrm-fs.gemspec

@@ -0,0 +1,36 @@
+require 'date'
+
+version = File.read(File.expand_path('VERSION', __dir__)).strip
+
+Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = 'winrm-fs'
+  s.version = version
+  s.date = Date.today.to_s
+
+  s.author = ['Shawn Neal', 'Matt Wrock']
+  s.email = ['sneal@sneal.net', 'matt@mattwrock.com']
+  s.homepage = 'http://github.com/WinRb/winrm-fs'
+
+  s.summary = 'WinRM File System'
+  s.description = <<-EOF
+    Ruby library for file system operations via Windows Remote Management
+  EOF
+
+  s.files = `git ls-files`.split(/\n/)
+  s.require_path = 'lib'
+  s.rdoc_options = %w[-x test/ -x examples/]
+  s.extra_rdoc_files = %w[README.md LICENSE]
+
+  s.bindir = 'bin'
+  s.executables = ['rwinrmcp']
+  s.required_ruby_version = '>= 2.2.0'
+  s.add_runtime_dependency 'erubis', '~> 2.7'
+  s.add_runtime_dependency 'logging', ['>= 1.6.1', '< 3.0']
+  s.add_runtime_dependency 'rubyzip', '~> 1.1'
+  s.add_runtime_dependency 'winrm', '~> 2.0'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'rake', '~> 10.3'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rubocop', '~> 0.51'
+end

data/vendor/bundle/ruby/2.5.0/specifications/vagrant_cloud-2.0.1.gemspec

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+# stub: vagrant_cloud 2.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "vagrant_cloud".freeze
+  s.version = "2.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["HashiCorp".freeze, "Cargo Media".freeze]
+  s.date = "2018-10-17"
+  s.description = "Ruby library for the HashiCorp Vagrant Cloud API".freeze
+  s.email = "vagrant@hashicorp.com".freeze
+  s.homepage = "https://github.com/hashicorp/vagrant_cloud".freeze
+  s.licenses = ["MIT".freeze]
+  s.post_install_message = "NOTICE: As of the 2.0.0 release, the vagrant_cloud gem provides library functionality\n        and no longer includes a command line client. For a command line client,\n        use the `vagrant cloud` subcommand from Vagrant. Vagrant can be downloaded\n        from: https://www.vagrantup.com/downloads.html".freeze
+  s.rubygems_version = "2.7.7".freeze
+  s.summary = "Vagrant Cloud API Library".freeze
+
+  s.installed_by_version = "2.7.7" if s.respond_to? :installed_by_version
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rest-client>.freeze, ["~> 2.0.2"])
+      s.add_development_dependency(%q<rake>.freeze, ["~> 10.4"])
+      s.add_development_dependency(%q<rspec>.freeze, ["~> 3.0"])
+      s.add_development_dependency(%q<rubocop>.freeze, ["~> 0.59.1"])
+      s.add_development_dependency(%q<webmock>.freeze, ["~> 3.0"])
+    else
+      s.add_dependency(%q<rest-client>.freeze, ["~> 2.0.2"])
+      s.add_dependency(%q<rake>.freeze, ["~> 10.4"])
+      s.add_dependency(%q<rspec>.freeze, ["~> 3.0"])
+      s.add_dependency(%q<rubocop>.freeze, ["~> 0.59.1"])
+      s.add_dependency(%q<webmock>.freeze, ["~> 3.0"])
+    end
+  else
+    s.add_dependency(%q<rest-client>.freeze, ["~> 2.0.2"])
+    s.add_dependency(%q<rake>.freeze, ["~> 10.4"])
+    s.add_dependency(%q<rspec>.freeze, ["~> 3.0"])
+    s.add_dependency(%q<rubocop>.freeze, ["~> 0.59.1"])
+    s.add_dependency(%q<webmock>.freeze, ["~> 3.0"])
+  end
+end