rubyzip 0.9.1 → 2.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35bd078119c42cd2250fadd127a0feae3299184b0bf90804c3ff0bc28d1c427f
+  data.tar.gz: 98e034b50a428ff970f25b28348993d938a88c5d5c93506561761f260062c059
+SHA512:
+  metadata.gz: 421a8884fbfe6f720e2e0da35f34e4208b96f83529faf5cba03501aa2693d95d51b9c19e04e4567801de1822120a0e14faf1c4d0991a164b8f0d011eaa6c0f7b
+  data.tar.gz: 59f29c6b49a14c777605224b351d8d14f7fdfe88a2ffc75a5f2120f51152831ed9afa04d8daf1f971bad982c3bcdd86e17d5616c8c9d57ddff7509b7f59e58b1

data/README.md

@@ -0,0 +1,354 @@
+# 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 2.4 or greater (for rubyzip 2.0; use 1.x for older rubies)
+
+## 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
+MAX_SIZE = 1024**2 # 1MiB (but of course you can increase this)
+Zip::File.open('foo.zip') do |zip_file|
+  # Handle entries one by one
+  zip_file.each do |entry|
+    puts "Extracting #{entry.name}"
+    raise 'File too large when extracted' if entry.size > MAX_SIZE
+
+    # Extract to file or directory based on name in the archive
+    entry.extract
+
+    # Read into memory
+    content = entry.get_input_stream.read
+  end
+
+  # Find specific entry
+  entry = zip_file.glob('*.csv').first
+  raise 'File too large when extracted' if entry.size > MAX_SIZE
+  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
+
+### Existing Files
+
+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
+```
+
+### Non-ASCII Names
+
+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
+```
+
+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`
+
+### Date Validation
+
+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
+```
+
+### Size Validation
+
+By default (in rubyzip >= 2.0), rubyzip's `extract` method checks that an entry's reported uncompressed size is not (significantly) smaller than its actual size. This is to help you protect your application against [zip bombs](https://en.wikipedia.org/wiki/Zip_bomb). Before `extract`ing an entry, you should check that its size is in the range you expect. For example, if your application supports processing up to 100 files at once, each up to 10MiB, your zip extraction code might look like:
+
+```ruby
+MAX_FILE_SIZE = 10 * 1024**2 # 10MiB
+MAX_FILES = 100
+Zip::File.open('foo.zip') do |zip_file|
+  num_files = 0
+  zip_file.each do |entry|
+    num_files += 1 if entry.file?
+    raise 'Too many extracted files' if num_files > MAX_FILES
+    raise 'File too large when extracted' if entry.size > MAX_FILE_SIZE
+    entry.extract
+  end
+end
+```
+
+If you need to extract zip files that report incorrect uncompressed sizes and you really trust them not too be too large, you can disable this setting with
+```ruby
+Zip.validate_entry_sizes = false
+```
+
+Note that if you use the lower level `Zip::InputStream` interface, `rubyzip` does *not* check the entry `size`s. In this case, the caller is responsible for making sure it does not read more data than expected from the input stream.
+
+### Default Compression
+
+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`
+
+### Zip64 Support
+
+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.
+
+### Block Form
+
+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
+```
+
+## 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/Rakefile

@@ -1,110 +1,21 @@
-# Rakefile for RubyGems      -*- ruby -*-
-
-require 'rubygems'
-require 'rake/clean'
+require 'bundler/gem_tasks'
 require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/contrib/sshpublisher'
-require 'net/ftp'
-
-PKG_NAME = 'rubyzip'
-PKG_VERSION = File.read('lib/zip/zip.rb').match(/\s+VERSION\s*=\s*'(.*)'/)[1]
-
-PKG_FILES = FileList.new
-
-PKG_FILES.add %w{ README NEWS TODO ChangeLog install.rb Rakefile }
-PKG_FILES.add %w{ samples/*.rb }
-PKG_FILES.add %w{ test/*.rb }
-PKG_FILES.add %w{ test/data/* }
-PKG_FILES.exclude "test/data/generated"
-PKG_FILES.add %w{ lib/**/*.rb }
-
-def clobberFromCvsIgnore(path)
-  CLOBBER.add File.readlines(path+'/.cvsignore').map { 
-    |f| File.join(path, f.chomp) 
-  } rescue StandardError
-end
+require 'rubocop/rake_task'
 
-clobberFromCvsIgnore '.'
-clobberFromCvsIgnore 'samples'
-clobberFromCvsIgnore 'test'
-clobberFromCvsIgnore 'test/data'
+task default: :test
 
-task :default => [:test]
-
-desc "Run unit tests"
-task :test do
-  ruby %{-C test alltests.rb}
-end
-
-# Shortcuts for test targets
-task :ut => [:test]
-
-spec = Gem::Specification.new do |s|
-  s.name = PKG_NAME
-  s.version = PKG_VERSION
-  s.author = "Thomas Sondergaard"
-  s.email = "thomas(at)sondergaard.cc"
-  s.homepage = "http://rubyzip.sourceforge.net/"
-  s.platform = Gem::Platform::RUBY
-  s.summary = "rubyzip is a ruby module for reading and writing zip files"
-  s.files = PKG_FILES.to_a
-  s.require_path = 'lib'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib'
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_zip = true
-  pkg.need_tar = true
-end
+RuboCop::RakeTask.new
 
-Rake::RDocTask.new do |rd|
-  rd.main = "README"
-  rd.rdoc_files.add %W{ lib/zip/*.rb README NEWS TODO ChangeLog }
-  rd.options << "--title 'rubyzip documentation' --webcvs http://cvs.sourceforge.net/viewcvs.py/rubyzip/rubyzip/"
-#  rd.options << "--all"
-end
-
-desc "Publish documentation"
-task :pdoc => [:rdoc] do
-  Rake::SshFreshDirPublisher.
-       new("thomas@rubyzip.sourceforge.net", "/home/groups/r/ru/rubyzip/htdocs", "html").upload
-end
-
-desc "Publish package"
-task :ppackage => [:package] do
-  Net::FTP.open("upload.sourceforge.net", 
-                "ftp", 
-                ENV['USER']+"@"+ENV['HOSTNAME']) {
-    |ftpclient|
-    ftpclient.passive = true
-    ftpclient.chdir "incoming"
-    Dir['pkg/*.{tgz,zip,gem}'].each {
-      |e|
-      ftpclient.putbinaryfile(e, File.basename(e))
-    }
-  }
-end
-
-desc "Generate the ChangeLog file"
-task :ChangeLog do
-  puts "Updating ChangeLog"
-  system %{cvs2cl}
-end
-
-desc "Make a release"
-task :release => [:tag_release, :pdoc, :ppackage] do
-end
-
-desc "Make a release tag"
-task :tag_release do
-  tag = "release-#{PKG_VERSION.gsub('.','-')}"
-
-  puts "Checking for tag '#{tag}'"
-  if (Regexp.new("^\\s+#{tag}") =~ `cvs log README`)
-    abort "Tag '#{tag}' already exists"
-  end
-  puts "Tagging module with '#{tag}'"
-  system("cvs tag #{tag}")
-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/TODO

@@ -4,7 +4,6 @@
 * 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
-* SUggestion: ZipInputStream/ZipOutputStream should accept an IO object in addition to a filename.
 * (is buffering used anywhere with write?)
 * Inflater.sysread should pass the buffer to produce_input.
 * Implement ZipFsDir.glob