vagrant-unbundled 2.2.4.0 → 2.2.5.0

data/vendor/bundle/ruby/2.6.0/gems/mime-types-data-3.2019.0904/types/world.yaml

@@ -0,0 +1,8 @@
+---
+- !ruby/object:MIME::Type
+  content-type: x-world/x-vrml
+  encoding: base64
+  extensions:
+  - wrl
+  - vrml
+  registered: false

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/README.md

@@ -0,0 +1,313 @@
+# rubyzip
+
+[![Gem Version](https://badge.fury.io/rb/rubyzip.svg)](http://badge.fury.io/rb/rubyzip)
+[![Build Status](https://secure.travis-ci.org/rubyzip/rubyzip.svg)](http://travis-ci.org/rubyzip/rubyzip)
+[![Code Climate](https://codeclimate.com/github/rubyzip/rubyzip.svg)](https://codeclimate.com/github/rubyzip/rubyzip)
+[![Coverage Status](https://img.shields.io/coveralls/rubyzip/rubyzip.svg)](https://coveralls.io/r/rubyzip/rubyzip?branch=master)
+
+Rubyzip is a ruby library for reading and writing zip files.
+
+## Important note
+
+The Rubyzip interface has changed!!! No need to do `require "zip/zip"` and `Zip` prefix in class names removed.
+
+If you have issues with any third-party gems that require an old version of rubyzip, you can use this workaround:
+
+```ruby
+gem 'rubyzip', '>= 1.0.0' # will load new rubyzip version
+gem 'zip-zip' # will load compatibility for old rubyzip API.
+```
+
+## Requirements
+
+- Ruby 1.9.2 or greater
+
+## Installation
+
+Rubyzip is available on RubyGems:
+
+```
+gem install rubyzip
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'rubyzip'
+```
+
+## Usage
+
+### Basic zip archive creation
+
+```ruby
+require 'rubygems'
+require 'zip'
+
+folder = "Users/me/Desktop/stuff_to_zip"
+input_filenames = ['image.jpg', 'description.txt', 'stats.csv']
+
+zipfile_name = "/Users/me/Desktop/archive.zip"
+
+Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
+  input_filenames.each do |filename|
+    # Two arguments:
+    # - The name of the file as it will appear in the archive
+    # - The original file, including the path to find it
+    zipfile.add(filename, File.join(folder, filename))
+  end
+  zipfile.get_output_stream("myFile") { |f| f.write "myFile contains just this" }
+end
+```
+
+### Zipping a directory recursively
+
+Copy from [here](https://github.com/rubyzip/rubyzip/blob/9d891f7353e66052283562d3e252fe380bb4b199/samples/example_recursive.rb)
+
+```ruby
+require 'zip'
+
+# This is a simple example which uses rubyzip to
+# recursively generate a zip file from the contents of
+# a specified directory. The directory itself is not
+# included in the archive, rather just its contents.
+#
+# Usage:
+#   directory_to_zip = "/tmp/input"
+#   output_file = "/tmp/out.zip"
+#   zf = ZipFileGenerator.new(directory_to_zip, output_file)
+#   zf.write()
+class ZipFileGenerator
+  # Initialize with the directory to zip and the location of the output archive.
+  def initialize(input_dir, output_file)
+    @input_dir = input_dir
+    @output_file = output_file
+  end
+
+  # Zip the input directory.
+  def write
+    entries = Dir.entries(@input_dir) - %w[. ..]
+
+    ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
+      write_entries entries, '', zipfile
+    end
+  end
+
+  private
+
+  # A helper method to make the recursion work.
+  def write_entries(entries, path, zipfile)
+    entries.each do |e|
+      zipfile_path = path == '' ? e : File.join(path, e)
+      disk_file_path = File.join(@input_dir, zipfile_path)
+
+      if File.directory? disk_file_path
+        recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+      else
+        put_into_archive(disk_file_path, zipfile, zipfile_path)
+      end
+    end
+  end
+
+  def recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+    zipfile.mkdir zipfile_path
+    subdir = Dir.entries(disk_file_path) - %w[. ..]
+    write_entries subdir, zipfile_path, zipfile
+  end
+
+  def put_into_archive(disk_file_path, zipfile, zipfile_path)
+    zipfile.add(zipfile_path, disk_file_path)
+  end
+end
+```
+
+### Save zip archive entries in sorted by name state
+
+To save zip archives in sorted order like below, you need to set `::Zip.sort_entries` to `true`
+
+```
+Vegetable/
+Vegetable/bean
+Vegetable/carrot
+Vegetable/celery
+fruit/
+fruit/apple
+fruit/kiwi
+fruit/mango
+fruit/orange
+```
+
+After this, entries in the zip archive will be saved in ordered state.
+
+### Default permissions of zip archives
+
+On Posix file systems the default file permissions applied to a new archive
+are (0666 - umask), which mimics the behavior of standard tools such as `touch`.
+
+On Windows the default file permissions are set to 0644 as suggested by the
+[Ruby File documentation](http://ruby-doc.org/core-2.2.2/File.html).
+
+When modifying a zip archive the file permissions of the archive are preserved.
+
+### Reading a Zip file
+
+```ruby
+Zip::File.open('foo.zip') do |zip_file|
+  # Handle entries one by one
+  zip_file.each do |entry|
+    # Extract to file/directory/symlink
+    puts "Extracting #{entry.name}"
+    entry.extract(dest_file)
+
+    # Read into memory
+    content = entry.get_input_stream.read
+  end
+
+  # Find specific entry
+  entry = zip_file.glob('*.csv').first
+  puts entry.get_input_stream.read
+end
+```
+
+#### Notice about ::Zip::InputStream
+
+`::Zip::InputStream` usable for fast reading zip file content because it not read Central directory.
+
+But there is one exception when it is not working - General Purpose Flag Bit 3.
+
+> If bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written. The fields in the local header are filled with zero, and the CRC-32 and size are appended in a 12-byte structure (optionally preceded by a 4-byte signature) immediately after the compressed data
+
+If `::Zip::InputStream` finds such entry in the zip archive it will raise an exception.
+
+### Password Protection (Experimental)
+
+Rubyzip supports reading/writing zip files with traditional zip encryption (a.k.a. "ZipCrypto"). AES encryption is not yet supported. It can be used with buffer streams, e.g.:
+
+```ruby
+Zip::OutputStream.write_buffer(::StringIO.new(''), Zip::TraditionalEncrypter.new('password')) do |out|
+  out.put_next_entry("my_file.txt")
+  out.write my_data
+end.string
+```
+
+This is an experimental feature and the interface for encryption may change in future versions.
+
+## Known issues
+
+### Modify docx file with rubyzip
+
+Use `write_buffer` instead `open`. Thanks to @jondruse
+
+```ruby
+buffer = Zip::OutputStream.write_buffer do |out|
+  @zip_file.entries.each do |e|
+    unless [DOCUMENT_FILE_PATH, RELS_FILE_PATH].include?(e.name)
+      out.put_next_entry(e.name)
+      out.write e.get_input_stream.read
+     end
+  end
+
+  out.put_next_entry(DOCUMENT_FILE_PATH)
+  out.write xml_doc.to_xml(:indent => 0).gsub("\n","")
+
+  out.put_next_entry(RELS_FILE_PATH)
+  out.write rels.to_xml(:indent => 0).gsub("\n","")
+end
+
+File.open(new_path, "wb") {|f| f.write(buffer.string) }
+```
+
+## Configuration
+
+By default, rubyzip will not overwrite files if they already exist inside of the extracted path. To change this behavior, you may specify a configuration option like so:
+
+```ruby
+Zip.on_exists_proc = true
+```
+
+If you're using rubyzip with rails, consider placing this snippet of code in an initializer file such as `config/initializers/rubyzip.rb`
+
+Additionally, if you want to configure rubyzip to overwrite existing files while creating a .zip file, you can do so with the following:
+
+```ruby
+Zip.continue_on_exists_proc = true
+```
+
+If you want to store non-english names and want to open them on Windows(pre 7) you need to set this option:
+
+```ruby
+Zip.unicode_names = true
+```
+
+Some zip files might have an invalid date format, which will raise a warning. You can hide this warning with the following setting:
+
+```ruby
+Zip.warn_invalid_date = false
+```
+
+You can set the default compression level like so:
+
+```ruby
+Zip.default_compression = Zlib::DEFAULT_COMPRESSION
+```
+
+It defaults to `Zlib::DEFAULT_COMPRESSION`. Possible values are `Zlib::BEST_COMPRESSION`, `Zlib::DEFAULT_COMPRESSION` and `Zlib::NO_COMPRESSION`
+
+Sometimes file names inside zip contain non-ASCII characters. If you can assume which encoding was used for such names and want to be able to find such entries using `find_entry` then you can force assumed encoding like so:
+
+```ruby
+Zip.force_entry_names_encoding = 'UTF-8'
+```
+
+Allowed encoding names are the same as accepted by `String#force_encoding`
+
+You can set multiple settings at the same time by using a block:
+
+```ruby
+  Zip.setup do |c|
+    c.on_exists_proc = true
+    c.continue_on_exists_proc = true
+    c.unicode_names = true
+    c.default_compression = Zlib::BEST_COMPRESSION
+  end
+```
+
+By default, Zip64 support is disabled for writing. To enable it do this:
+
+```ruby
+Zip.write_zip64_support = true
+```
+
+_NOTE_: If you will enable Zip64 writing then you will need zip extractor with Zip64 support to extract archive.
+
+## Developing
+
+To run the test you need to do this:
+
+```
+bundle install
+rake
+```
+
+## Website and Project Home
+
+http://github.com/rubyzip/rubyzip
+
+http://rdoc.info/github/rubyzip/rubyzip/master/frames
+
+## Authors
+
+Alexander Simonov ( alex at simonov.me)
+
+Alan Harper ( alan at aussiegeek.net)
+
+Thomas Sondergaard (thomas at sondergaard.cc)
+
+Technorama Ltd. (oss-ruby-zip at technorama.net)
+
+extra-field support contributed by Tatsuki Sugiura (sugi at nemui.org)
+
+## License
+
+Rubyzip is distributed under the same license as ruby. See
+http://www.ruby-lang.org/en/LICENSE.txt

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task default: :test
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib'
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+# Rake::TestTask.new(:zip64_full_test) do |test|
+#  test.libs << File.join(File.dirname(__FILE__), 'lib')
+#  test.libs << File.join(File.dirname(__FILE__), 'test')
+#  test.pattern = File.join(File.dirname(__FILE__), 'test/zip64_full_test.rb')
+#  test.verbose = true
+# end

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/TODO

@@ -0,0 +1,15 @@
+
+* ZipInputStream: Support zip-files with trailing data descriptors
+* Adjust rdoc stylesheet to advertise inherited methods if possible
+* Suggestion: Add ZipFile/ZipInputStream example that demonstrates extracting all entries.
+* Suggestion: ZipFile#extract destination should default to "."
+* Suggestion: ZipEntry should have extract(), get_input_stream() methods etc
+* (is buffering used anywhere with write?)
+* Inflater.sysread should pass the buffer to produce_input.
+* Implement ZipFsDir.glob
+* ZipFile.checkIntegrity method
+* non-MSDOS permission attributes
+** See mail from Ned Konz to ruby-talk subj. "Re: SV: [ANN] Archive 0.2"
+* Packager version, required unpacker version in zip headers
+** See mail from Ned Konz to ruby-talk subj. "Re: SV: [ANN] Archive 0.2"
+* implement storing attributes and ownership information

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/lib/zip/central_directory.rb

@@ -0,0 +1,208 @@
+module Zip
+  class CentralDirectory
+    include Enumerable
+
+    END_OF_CDS             = 0x06054b50
+    ZIP64_END_OF_CDS       = 0x06064b50
+    ZIP64_EOCD_LOCATOR     = 0x07064b50
+    MAX_END_OF_CDS_SIZE    = 65_536 + 18
+    STATIC_EOCD_SIZE       = 22
+
+    attr_reader :comment
+
+    # Returns an Enumerable containing the entries.
+    def entries
+      @entry_set.entries
+    end
+
+    def initialize(entries = EntrySet.new, comment = '') #:nodoc:
+      super()
+      @entry_set = entries.kind_of?(EntrySet) ? entries : EntrySet.new(entries)
+      @comment   = comment
+    end
+
+    def write_to_stream(io) #:nodoc:
+      cdir_offset = io.tell
+      @entry_set.each { |entry| entry.write_c_dir_entry(io) }
+      eocd_offset = io.tell
+      cdir_size = eocd_offset - cdir_offset
+      if ::Zip.write_zip64_support
+        need_zip64_eocd = cdir_offset > 0xFFFFFFFF || cdir_size > 0xFFFFFFFF || @entry_set.size > 0xFFFF
+        need_zip64_eocd ||= @entry_set.any? { |entry| entry.extra['Zip64'] }
+        if need_zip64_eocd
+          write_64_e_o_c_d(io, cdir_offset, cdir_size)
+          write_64_eocd_locator(io, eocd_offset)
+        end
+      end
+      write_e_o_c_d(io, cdir_offset, cdir_size)
+    end
+
+    def write_e_o_c_d(io, offset, cdir_size) #:nodoc:
+      tmp = [
+        END_OF_CDS,
+        0, # @numberOfThisDisk
+        0, # @numberOfDiskWithStartOfCDir
+        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
+        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
+        [cdir_size, 0xFFFFFFFF].min,
+        [offset, 0xFFFFFFFF].min,
+        @comment ? @comment.bytesize : 0
+      ]
+      io << tmp.pack('VvvvvVVv')
+      io << @comment
+    end
+
+    private :write_e_o_c_d
+
+    def write_64_e_o_c_d(io, offset, cdir_size) #:nodoc:
+      tmp = [
+        ZIP64_END_OF_CDS,
+        44, # size of zip64 end of central directory record (excludes signature and field itself)
+        VERSION_MADE_BY,
+        VERSION_NEEDED_TO_EXTRACT_ZIP64,
+        0, # @numberOfThisDisk
+        0, # @numberOfDiskWithStartOfCDir
+        @entry_set ? @entry_set.size : 0, # number of entries on this disk
+        @entry_set ? @entry_set.size : 0, # number of entries total
+        cdir_size, # size of central directory
+        offset, # offset of start of central directory in its disk
+      ]
+      io << tmp.pack('VQ<vvVVQ<Q<Q<Q<')
+    end
+
+    private :write_64_e_o_c_d
+
+    def write_64_eocd_locator(io, zip64_eocd_offset)
+      tmp = [
+        ZIP64_EOCD_LOCATOR,
+        0, # number of disk containing the start of zip64 eocd record
+        zip64_eocd_offset, # offset of the start of zip64 eocd record in its disk
+        1 # total number of disks
+      ]
+      io << tmp.pack('VVQ<V')
+    end
+
+    private :write_64_eocd_locator
+
+    def read_64_e_o_c_d(buf) #:nodoc:
+      buf                                           = get_64_e_o_c_d(buf)
+      @size_of_zip64_e_o_c_d                        = Entry.read_zip_64_long(buf)
+      @version_made_by                              = Entry.read_zip_short(buf)
+      @version_needed_for_extract                   = Entry.read_zip_short(buf)
+      @number_of_this_disk                          = Entry.read_zip_long(buf)
+      @number_of_disk_with_start_of_cdir            = Entry.read_zip_long(buf)
+      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_64_long(buf)
+      @size                                         = Entry.read_zip_64_long(buf)
+      @size_in_bytes                                = Entry.read_zip_64_long(buf)
+      @cdir_offset                                  = Entry.read_zip_64_long(buf)
+      @zip_64_extensible                            = buf.slice!(0, buf.bytesize)
+      raise Error, 'Zip consistency problem while reading eocd structure' unless buf.empty?
+    end
+
+    def read_e_o_c_d(buf) #:nodoc:
+      buf                                           = get_e_o_c_d(buf)
+      @number_of_this_disk                          = Entry.read_zip_short(buf)
+      @number_of_disk_with_start_of_cdir            = Entry.read_zip_short(buf)
+      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_short(buf)
+      @size                                         = Entry.read_zip_short(buf)
+      @size_in_bytes                                = Entry.read_zip_long(buf)
+      @cdir_offset                                  = Entry.read_zip_long(buf)
+      comment_length                                = Entry.read_zip_short(buf)
+      @comment                                      = if comment_length.to_i <= 0
+                                                        buf.slice!(0, buf.size)
+                                                      else
+                                                        buf.read(comment_length)
+                                                      end
+      raise Error, 'Zip consistency problem while reading eocd structure' unless buf.empty?
+    end
+
+    def read_central_directory_entries(io) #:nodoc:
+      begin
+        io.seek(@cdir_offset, IO::SEEK_SET)
+      rescue Errno::EINVAL
+        raise Error, 'Zip consistency problem while reading central directory entry'
+      end
+      @entry_set = EntrySet.new
+      @size.times do
+        @entry_set << Entry.read_c_dir_entry(io)
+      end
+    end
+
+    def read_from_stream(io) #:nodoc:
+      buf = start_buf(io)
+      if zip64_file?(buf)
+        read_64_e_o_c_d(buf)
+      else
+        read_e_o_c_d(buf)
+      end
+      read_central_directory_entries(io)
+    end
+
+    def get_e_o_c_d(buf) #:nodoc:
+      sig_index = buf.rindex([END_OF_CDS].pack('V'))
+      raise Error, 'Zip end of central directory signature not found' unless sig_index
+      buf = buf.slice!((sig_index + 4)..(buf.bytesize))
+
+      def buf.read(count)
+        slice!(0, count)
+      end
+
+      buf
+    end
+
+    def zip64_file?(buf)
+      buf.rindex([ZIP64_END_OF_CDS].pack('V')) && buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
+    end
+
+    def start_buf(io)
+      begin
+        io.seek(-MAX_END_OF_CDS_SIZE, IO::SEEK_END)
+      rescue Errno::EINVAL
+        io.seek(0, IO::SEEK_SET)
+      end
+      io.read
+    end
+
+    def get_64_e_o_c_d(buf) #:nodoc:
+      zip_64_start = buf.rindex([ZIP64_END_OF_CDS].pack('V'))
+      raise Error, 'Zip64 end of central directory signature not found' unless zip_64_start
+      zip_64_locator = buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
+      raise Error, 'Zip64 end of central directory signature locator not found' unless zip_64_locator
+      buf = buf.slice!((zip_64_start + 4)..zip_64_locator)
+
+      def buf.read(count)
+        slice!(0, count)
+      end
+
+      buf
+    end
+
+    # For iterating over the entries.
+    def each(&proc)
+      @entry_set.each(&proc)
+    end
+
+    # Returns the number of entries in the central directory (and
+    # consequently in the zip archive).
+    def size
+      @entry_set.size
+    end
+
+    def self.read_from_stream(io) #:nodoc:
+      cdir = new
+      cdir.read_from_stream(io)
+      return cdir
+    rescue Error
+      return nil
+    end
+
+    def ==(other) #:nodoc:
+      return false unless other.kind_of?(CentralDirectory)
+      @entry_set.entries.sort == other.entries.sort && comment == other.comment
+    end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/lib/zip/compressor.rb

@@ -0,0 +1,9 @@
+module Zip
+  class Compressor #:nodoc:all
+    def finish; end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/lib/zip/constants.rb

@@ -0,0 +1,63 @@
+module Zip
+  RUNNING_ON_WINDOWS = RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
+
+  CENTRAL_DIRECTORY_ENTRY_SIGNATURE = 0x02014b50
+  CDIR_ENTRY_STATIC_HEADER_LENGTH   = 46
+
+  LOCAL_ENTRY_SIGNATURE                  = 0x04034b50
+  LOCAL_ENTRY_STATIC_HEADER_LENGTH       = 30
+  LOCAL_ENTRY_TRAILING_DESCRIPTOR_LENGTH = 4 + 4 + 4
+  VERSION_MADE_BY                        = 52 # this library's version
+  VERSION_NEEDED_TO_EXTRACT              = 20
+  VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
+
+  FILE_TYPE_FILE    = 0o10
+  FILE_TYPE_DIR     = 0o04
+  FILE_TYPE_SYMLINK = 0o12
+
+  FSTYPE_FAT      = 0
+  FSTYPE_AMIGA    = 1
+  FSTYPE_VMS      = 2
+  FSTYPE_UNIX     = 3
+  FSTYPE_VM_CMS   = 4
+  FSTYPE_ATARI    = 5
+  FSTYPE_HPFS     = 6
+  FSTYPE_MAC      = 7
+  FSTYPE_Z_SYSTEM = 8
+  FSTYPE_CPM      = 9
+  FSTYPE_TOPS20   = 10
+  FSTYPE_NTFS     = 11
+  FSTYPE_QDOS     = 12
+  FSTYPE_ACORN    = 13
+  FSTYPE_VFAT     = 14
+  FSTYPE_MVS      = 15
+  FSTYPE_BEOS     = 16
+  FSTYPE_TANDEM   = 17
+  FSTYPE_THEOS    = 18
+  FSTYPE_MAC_OSX  = 19
+  FSTYPE_ATHEOS   = 30
+
+  FSTYPES = {
+    FSTYPE_FAT      => 'FAT'.freeze,
+    FSTYPE_AMIGA    => 'Amiga'.freeze,
+    FSTYPE_VMS      => 'VMS (Vax or Alpha AXP)'.freeze,
+    FSTYPE_UNIX     => 'Unix'.freeze,
+    FSTYPE_VM_CMS   => 'VM/CMS'.freeze,
+    FSTYPE_ATARI    => 'Atari ST'.freeze,
+    FSTYPE_HPFS     => 'OS/2 or NT HPFS'.freeze,
+    FSTYPE_MAC      => 'Macintosh'.freeze,
+    FSTYPE_Z_SYSTEM => 'Z-System'.freeze,
+    FSTYPE_CPM      => 'CP/M'.freeze,
+    FSTYPE_TOPS20   => 'TOPS-20'.freeze,
+    FSTYPE_NTFS     => 'NTFS'.freeze,
+    FSTYPE_QDOS     => 'SMS/QDOS'.freeze,
+    FSTYPE_ACORN    => 'Acorn RISC OS'.freeze,
+    FSTYPE_VFAT     => 'Win32 VFAT'.freeze,
+    FSTYPE_MVS      => 'MVS'.freeze,
+    FSTYPE_BEOS     => 'BeOS'.freeze,
+    FSTYPE_TANDEM   => 'Tandem NSK'.freeze,
+    FSTYPE_THEOS    => 'Theos'.freeze,
+    FSTYPE_MAC_OSX  => 'Mac OS/X (Darwin)'.freeze,
+    FSTYPE_ATHEOS   => 'AtheOS'.freeze
+  }.freeze
+end

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/lib/zip/crypto/encryption.rb

@@ -0,0 +1,11 @@
+module Zip
+  class Encrypter #:nodoc:all
+  end
+
+  class Decrypter
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/vendor/bundle/ruby/2.6.0/gems/rubyzip-1.2.4/lib/zip/crypto/null_encryption.rb

@@ -0,0 +1,43 @@
+module Zip
+  module NullEncryption
+    def header_bytesize
+      0
+    end
+
+    def gp_flags
+      0
+    end
+  end
+
+  class NullEncrypter < Encrypter
+    include NullEncryption
+
+    def header(_mtime)
+      ''
+    end
+
+    def encrypt(data)
+      data
+    end
+
+    def data_descriptor(_crc32, _compressed_size, _uncomprssed_size)
+      ''
+    end
+
+    def reset!; end
+  end
+
+  class NullDecrypter < Decrypter
+    include NullEncryption
+
+    def decrypt(data)
+      data
+    end
+
+    def reset!(_header); end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.