vagrant-unbundled 2.2.6.1 → 2.2.6.2

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/core/tmp_zip.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+#
+# 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 'delegate'
+require 'pathname'
+require 'tempfile'
+require 'zip'
+
+module WinRM
+  module FS
+    module Core
+      # A temporary Zip file for a given directory.
+      #
+      # @author Fletcher Nichol <fnichol@nichol.ca>
+      class TmpZip
+        # Contructs a new Zip file for the given directory.
+        #
+        # There are 2 ways to interpret the directory path:
+        #
+        # * If the directory has no path separator terminator, then the
+        #   directory basename will be used as the base directory in the
+        #   resulting zip file.
+        # * If the directory has a path separator terminator (such as `/` or
+        #   `\\`), then the entries under the directory will be added to the
+        #   resulting zip file.
+        #
+        # The following emaples assume a directory tree structure of:
+        #
+        #     src
+        #     |-- alpha.txt
+        #     |-- beta.txt
+        #     \-- sub
+        #         \-- charlie.txt
+        #
+        # @example Including the base directory in the zip file
+        #
+        #   TmpZip.new("/path/to/src")
+        #   # produces a zip file with entries:
+        #   # - src/alpha.txt
+        #   # - src/beta.txt
+        #   # - src/sub/charlie.txt
+        #
+        # @example Excluding the base directory in the zip file
+        #
+        #   TmpZip.new("/path/to/src/")
+        #   # produces a zip file with entries:
+        #   # - alpha.txt
+        #   # - beta.txt
+        #   # - sub/charlie.txt
+        #
+        # @param dir [String,Pathname,#to_s] path to the directory
+        # @param logger [#debug,#debug?] an optional logger/ui object that
+        #   responds to `#debug` and `#debug?` (default `nil`)
+        def initialize(dir, logger = nil)
+          @logger = logger || Logging.logger[self]
+          @dir = clean_dirname(dir)
+          @zip_io = Tempfile.open(['tmpzip-', '.zip'], binmode: true)
+          write_zip
+          @zip_io.close
+        end
+
+        # @return [Pathname] path to zip file
+        def path
+          Pathname.new(zip_io.path) if zip_io.path
+        end
+
+        # Unlinks (deletes) the zip file from the filesystem.
+        def unlink
+          zip_io.unlink
+        end
+
+        private
+
+        # @return [Pathname] the directory used to create the Zip file
+        # @api private
+        attr_reader :dir
+
+        # @return [#debug] the logger
+        # @api private
+        attr_reader :logger
+
+        # @return [IO] the Zip file IO
+        # @api private
+        attr_reader :zip_io
+
+        # @return [Pathname] the pathname object representing dirname that
+        # doesn't have any of those ~ in it
+        # @api private
+        def clean_dirname(dir)
+          paths = Pathname.glob(dir)
+          raise "Expected Pathname.glob(dir) to return only dir, got #{paths}" if paths.length != 1
+
+          paths.first
+        end
+
+        # @return [Array<Pathname] all recursive files under the base
+        #   directory, excluding directories
+        # @api private
+        def entries
+          Pathname.glob(dir.join('**/*')).delete_if(&:directory?).sort
+        end
+
+        # (see Logging.log_subject)
+        # @api private
+        def log_subject
+          @log_subject ||= [self.class.to_s.split('::').last, path].join('::')
+        end
+
+        # Adds all file entries to the Zip output stream.
+        #
+        # @param zos [Zip::OutputStream] zip output stream
+        # @api private
+        def produce_zip_entries(zos)
+          entries.each do |entry|
+            entry_path = entry.relative_path_from(dir)
+            logger.debug "+++ Adding #{entry_path}"
+            zos.put_next_entry(
+              zip_entry(entry_path),
+              nil, nil, ::Zip::Entry::DEFLATED, Zlib::BEST_COMPRESSION
+            )
+            entry.open('rb') { |src| IO.copy_stream(src, zos) }
+          end
+          logger.debug '=== All files added.'
+        end
+
+        # Writes out a temporary Zip file.
+        #
+        # @api private
+        def write_zip
+          logger.debug 'Populating files'
+          Zip::OutputStream.write_buffer(NoDupIO.new(zip_io)) do |zos|
+            produce_zip_entries(zos)
+          end
+        end
+
+        def zip_entry(entry_path)
+          Zip::Entry.new(
+            zip_io.path,
+            entry_path.to_s,
+            nil, nil, nil, nil, nil, nil,
+            ::Zip::DOSTime.new(2000)
+          )
+        end
+
+        # Simple delegate wrapper to prevent `#dup` calls being made on IO
+        # objects. This is used to bypass an issue in the `Zip::Outputstream`
+        # constructor where an incoming IO is duplicated, leading to races
+        # on flushing the final stream to disk.
+        #
+        # @author Fletcher Nichol <fnichol@nichol.ca>
+        # @api private
+        class NoDupIO < SimpleDelegator
+          # @return [self] returns self and does *not* return a duplicate
+          #   object
+          def dup
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/exceptions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# 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.
+
+module WinRM
+  module FS
+    # WinRM-FS base class for errors
+    class WinRMFSError < StandardError; end
+
+    # Error that occurs when a file upload fails
+    class WinRMUploadError < WinRMFSError; end
+
+    # Error that occurs when a file download fails
+    class WinRMDownloadError < WinRMFSError; end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/file_manager.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# 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'
+require_relative 'scripts/scripts'
+require_relative 'core/file_transporter'
+
+module WinRM
+  module FS
+    # Perform file transfer operations between a local machine and winrm endpoint
+    class FileManager
+      # Creates a new FileManager instance
+      # @param [WinRM::Connection] WinRM web connection client
+      def initialize(connection)
+        @connection = connection
+        @logger = connection.logger
+      end
+
+      # Gets the SHA1 checksum of the specified file if it exists,
+      # otherwise ''
+      # @param [String] The remote file path
+      # @parms [String] The digest method
+      def checksum(path, digest = 'SHA1')
+        @logger.debug("checksum with #{digest}: #{path}")
+        script = WinRM::FS::Scripts.render('checksum', path: path, digest: digest)
+        @connection.shell(:powershell) { |e| e.run(script).stdout.chomp }
+      end
+
+      # Create the specifed directory recursively
+      # @param [String] The remote dir to create
+      # @return [Boolean] True if successful, otherwise false
+      def create_dir(path)
+        @logger.debug("create_dir: #{path}")
+        script = WinRM::FS::Scripts.render('create_dir', path: path)
+        @connection.shell(:powershell) { |e| e.run(script).exitcode == 0 }
+      end
+
+      # Deletes the file or directory at the specified path
+      # @param [String] The path to remove
+      # @return [Boolean] True if successful, otherwise False
+      def delete(path)
+        @logger.debug("deleting: #{path}")
+        script = WinRM::FS::Scripts.render('delete', path: path)
+        @connection.shell(:powershell) { |e| e.run(script).exitcode == 0 }
+      end
+
+      # Downloads the specified remote file to the specified local path
+      # @param [String] The full path on the remote machine
+      # @param [String] The full path to write the file to locally
+      # rubocop:disable Metrics/MethodLength
+      def download(remote_path, local_path, chunk_size = 1024 * 1024, first = true)
+        @logger.debug("downloading: #{remote_path} -> #{local_path} #{chunk_size}")
+        index = 0
+        output = _output_from_file(remote_path, chunk_size, index)
+        return download_dir(remote_path, local_path, chunk_size, first) if output.exitcode == 2
+
+        return false if output.exitcode >= 1
+
+        File.open(local_path, 'wb') do |fd|
+          out = _write_file(fd, output)
+          index += out.length
+          until out.empty?
+            output = _output_from_file(remote_path, chunk_size, index)
+            return false if output.exitcode >= 1
+
+            out = _write_file(fd, output)
+            index += out.length
+          end
+        end
+        true
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def _output_from_file(remote_path, chunk_size, index)
+        script = WinRM::FS::Scripts.render('download', path: remote_path, chunk_size: chunk_size, index: index)
+        @connection.shell(:powershell) { |e| e.run(script) }
+      end
+
+      def _write_file(tofd, output)
+        contents = output.stdout.gsub('\n\r', '')
+        out = Base64.decode64(contents)
+        out = out[0, out.length - 1] if out.end_with? "\x00"
+        return out if out.empty?
+
+        tofd.write(out)
+        out
+      end
+
+      # Checks to see if the given path exists on the target file system.
+      # @param [String] The full path to the directory or file
+      # @return [Boolean] True if the file/dir exists, otherwise false.
+      def exists?(path)
+        @logger.debug("exists?: #{path}")
+        script = WinRM::FS::Scripts.render('exists', path: path)
+        @connection.shell(:powershell) { |e| e.run(script).exitcode == 0 }
+      end
+
+      # Gets the current user's TEMP directory on the remote system, for example
+      # 'C:/Windows/Temp'
+      # @return [String] Full path to the temp directory
+      def temp_dir
+        @temp_dir ||= begin
+          (@connection.shell(:powershell) { |e| e.run('$env:TEMP') }).stdout.chomp.tr('\\', '/')
+        end
+      end
+
+      # Upload one or more local files and directories to a remote directory
+      # @example copy a single file to a winrm endpoint
+      #
+      #   file_manager.upload('/Users/sneal/myfile.txt', 'c:/foo/myfile.txt')
+      #
+      # @example copy a single directory to a winrm endpoint
+      #
+      #   file_manager.upload('c:/dev/my_dir', '$env:AppData')
+      #
+      # @param [String] A path to a local directory or file that will be copied
+      #   to the remote Windows box.
+      # @param [String] The target directory or file
+      #   This path may contain powershell style environment variables
+      # @yieldparam [Fixnum] Number of bytes copied in current payload sent to the winrm endpoint
+      # @yieldparam [Fixnum] The total number of bytes to be copied
+      # @yieldparam [String] Path of file being copied
+      # @yieldparam [String] Target path on the winrm endpoint
+      # @return [Fixnum] The total number of bytes copied
+      def upload(local_path, remote_path, &block)
+        @connection.shell(:powershell) do |shell|
+          file_transporter ||= WinRM::FS::Core::FileTransporter.new(shell)
+          file_transporter.upload(local_path, remote_path, &block)[0]
+        end
+      end
+
+      private
+
+      def download_dir(remote_path, local_path, chunk_size, first)
+        local_path = File.join(local_path, File.basename(remote_path.to_s)) if first
+        FileUtils.mkdir_p(local_path) unless File.directory?(local_path)
+        command = "Get-ChildItem #{remote_path} | Select-Object Name"
+        @connection.shell(:powershell) { |e| e.run(command) }.stdout.strip.split(/\n/).drop(2).each do |file|
+          download(File.join(remote_path.to_s, file.strip), File.join(local_path, file.strip), chunk_size, false)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/check_files.ps1.erb

@@ -0,0 +1,49 @@
+$hash_file = <%= hash_file %>
+
+Function Cleanup($disposable) {
+  if (($disposable -ne $null) -and ($disposable.GetType().GetMethod("Dispose") -ne $null)) {
+    $disposable.Dispose()
+  }
+}
+
+Function Check-Files($h) {
+  return $h.GetEnumerator() | ForEach-Object {
+    $dst = Unresolve-Path $_.Value.target
+    $dst_changed = $false
+    if(Test-Path $dst -PathType Container) {
+      $dst_changed = $true
+      $dst = Join-Path $dst $_.Value.src_basename
+    }
+    New-Object psobject -Property @{
+      chk_exists = ($exists = Test-Path $dst -PathType Leaf)
+      src_sha1 = ($sMd5 = $_.Key)
+      dst_sha1 = ($dMd5 = if ($exists) { Get-SHA1Sum $dst } else { $null })
+      chk_dirty = ($dirty = if ($sMd5 -ne $dMd5) { $true } else { $false })
+      verifies = if ($dirty -eq $false) { $true } else { $false }
+      target_is_folder = $dst_changed
+    }
+  } | Select-Object -Property chk_exists,src_sha1,dst_sha1,chk_dirty,verifies,target_is_folder
+}
+
+Function Get-SHA1Sum($src) {
+  Try {
+    $c = [System.Security.Cryptography.SHA1]::Create()
+    $bytes = $c.ComputeHash(($in = (Get-Item $src).OpenRead()))
+    return ([System.BitConverter]::ToString($bytes)).Replace("-", "").ToLower()
+  } 
+  Finally {
+    Cleanup $c
+    Cleanup $in
+  }
+}
+
+Function Unresolve-Path($path) {
+  if ($path -eq $null) {
+    return $null
+  }
+  else {
+    return $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($path)
+  }
+}
+
+Check-Files $hash_file | ConvertTo-Csv -NoTypeInformation

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/checksum.ps1.erb

@@ -0,0 +1,13 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+
+if (Test-Path $path -PathType Leaf) {
+  $cryptoProv = [System.Security.Cryptography.<%= digest %>]::Create()
+  $file = [System.IO.File]::Open($path,
+      [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read)
+  $digest = ([System.BitConverter]::ToString($cryptoProv.ComputeHash($file)))
+  $digest = $digest.Replace("-","").ToLower()
+  $file.Close()
+
+  Write-Output $digest
+}

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/create_dir.ps1.erb

@@ -0,0 +1,6 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (!(Test-Path $path)) {
+  New-Item -ItemType Directory -Force -Path $path | Out-Null
+}
+exit 0

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/delete.ps1.erb

@@ -0,0 +1,6 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path) {
+  Remove-Item $path -Force -Recurse
+}
+exit 0

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/download.ps1.erb

@@ -0,0 +1,17 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+$index = <%= index %>
+$chunkSize = <%= chunk_size %>
+if (Test-Path $path -PathType Leaf) {
+  $file = [System.IO.File]::OpenRead($path)
+  $seekedTo = $file.Seek($index, [System.IO.SeekOrigin]::Begin)
+  $chunk = New-Object byte[] $chunkSize
+  $bytesRead = $file.Read($chunk, 0, $chunkSize)
+  $bytes = [System.convert]::ToBase64String($chunk[0..$bytesRead])
+  Write-Host $bytes
+  exit 0
+}
+ElseIf (Test-Path $path -PathType Container) {
+  exit 2
+}
+exit 1

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/exists.ps1.erb

@@ -0,0 +1,10 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path) {
+  $true
+  exit 0
+}
+else {
+  $false
+  exit 1
+}

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/extract_files.ps1.erb

@@ -0,0 +1,52 @@
+trap {
+  $e = $_.Exception
+  $e.InvocationInfo.ScriptName
+  do {
+    $e.Message
+    $e = $e.InnerException
+  } while ($e)
+  break
+}
+
+function folder($path){
+  $path | ? {-not (test-path $_)} | % {$null = mkdir $_}
+}
+
+Function Decode-Files($hash) {
+  foreach ($key in $hash.keys) {
+    $value = $hash[$key]
+    $tzip, $dst = $Value["tmpzip"], $Value["dst"]
+    if ($tzip) {Unzip-File $tzip $dst}
+    New-Object psobject -Property @{dst=$dst;src_sha1=$key;tmpzip=$tzip}
+  }
+}
+
+Function Unzip-File($src, $dst) {
+  $unpack = $src -replace '\.zip'
+  $dst_parent = Split-Path -Path $dst -Parent
+  if(!(Test-Path $dst_parent)) { $dst = $dst_parent }
+  folder $unpack, $dst
+  try {
+    try{
+      [IO.Compression.ZipFile]::ExtractToDirectory($src, $unpack)
+    }
+    catch {
+      Add-Type -AssemblyName System.IO.Compression.FileSystem -ErrorAction Stop
+      [IO.Compression.ZipFile]::ExtractToDirectory($src, $unpack)
+    }
+  }
+  catch {
+    Try {
+      $s = New-Object -ComObject Shell.Application
+      ($s.NameSpace($unpack)).CopyHere(($s.NameSpace($src)).Items(), 0x610) | Out-Null
+    }
+    Finally {
+      [void][Runtime.Interopservices.Marshal]::ReleaseComObject($s)
+    }
+  }
+  dir $unpack | cp -dest "$dst/" -force -recurse
+  rm $unpack -recurse -force
+}
+
+$hash_file = <%= hash_file %>
+Decode-Files $hash_file | ConvertTo-Csv -NoTypeInformation

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs/scripts/scripts.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# 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 'erubi'
+
+module WinRM
+  module FS
+    # PS1 scripts
+    module Scripts
+      # rubocop:disable Metrics/MethodLength
+      def self.render(template, context)
+        # rubocop:enable Metrics/MethodLength
+        template_path = File.expand_path(
+          "#{File.dirname(__FILE__)}/#{template}.ps1.erb"
+        )
+        template = File.read(template_path)
+        case context
+        when Hash
+          b = binding
+          locals = context.collect { |k, _| "#{k} = context[#{k.inspect}]; " }
+          b.eval(locals.join)
+        when Binding
+          b = context
+        when NilClass
+          b = binding
+        else
+          raise ArgumentError
+        end
+        b.eval(Erubi::Engine.new(template).src)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/winrm-fs-1.3.4/lib/winrm-fs.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# 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'
+require 'logger'
+require 'pathname'
+require_relative 'winrm-fs/exceptions'
+require_relative 'winrm-fs/file_manager'
+
+module WinRM
+  # WinRM File System
+  module FS
+    # Top level module code
+  end
+end

data/vendor/bundle/ruby/2.6.0/specifications/erubi-1.9.0.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+# stub: erubi 1.9.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "erubi".freeze
+  s.version = "1.9.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Jeremy Evans".freeze, "kuwata-lab.com".freeze]
+  s.date = "2019-09-25"
+  s.description = "Erubi is a ERB template engine for ruby. It is a simplified fork of Erubis".freeze
+  s.email = "code@jeremyevans.net".freeze
+  s.extra_rdoc_files = ["README.rdoc".freeze, "CHANGELOG".freeze, "MIT-LICENSE".freeze]
+  s.files = ["CHANGELOG".freeze, "MIT-LICENSE".freeze, "README.rdoc".freeze]
+  s.homepage = "https://github.com/jeremyevans/erubi".freeze
+  s.licenses = ["MIT".freeze]
+  s.rdoc_options = ["--quiet".freeze, "--line-numbers".freeze, "--inline-source".freeze, "--title".freeze, "Erubi: Small ERB Implementation".freeze, "--main".freeze, "README.rdoc".freeze]
+  s.rubygems_version = "3.0.6".freeze
+  s.summary = "Small ERB Implementation".freeze
+
+  s.installed_by_version = "3.0.6" 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_development_dependency(%q<minitest>.freeze, [">= 0"])
+      s.add_development_dependency(%q<minitest-global_expectations>.freeze, [">= 0"])
+    else
+      s.add_dependency(%q<minitest>.freeze, [">= 0"])
+      s.add_dependency(%q<minitest-global_expectations>.freeze, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<minitest>.freeze, [">= 0"])
+    s.add_dependency(%q<minitest-global_expectations>.freeze, [">= 0"])
+  end
+end