multi_zip 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e4e927a532bd99e7fc59c1a6f84da9bb8369694
+  data.tar.gz: 753a83ee20f222d33b04e29f4edd131062976ada
+SHA512:
+  metadata.gz: 11ba062b2125374d543c50f05c48045d51e5b62fc01ed0f8348a26a1b65159b9f40fa2702ad61600a07e3a75fab5fdbaf11815b4cf595edaf87984ab7dd8ee2b
+  data.tar.gz: 3a261d116078bc97320ff789ef2eeb7052dfe1d407c911036a462069535fb9a713420b65bb148c75c4f9644d0d0a66ff394360d066b2e102590c10f5255a5f78

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-*
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+rvm:
+  - ruby-head
+  - ree
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.1
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm:
+      - ruby-head
+      - rbx-2

data/BACKEND_CONSTANTS.md

@@ -0,0 +1,26 @@
+# rubyzip
+
+```ruby
+> require 'zip'
+ => true
+> Zip.constants
+ => [:DOSTime, :IOExtras, :Entry, :ExtraField, :EntrySet, :CentralDirectory, :File, :InputStream, :OutputStream, :Decompressor, :Compressor, :NullDecompressor, :NullCompressor, :NullInputStream, :PassThruCompressor, :PassThruDecompressor, :Inflater, :Deflater, :StreamableStream, :StreamableDirectory, :RUNNING_ON_WINDOWS, :CENTRAL_DIRECTORY_ENTRY_SIGNATURE, :CDIR_ENTRY_STATIC_HEADER_LENGTH, :LOCAL_ENTRY_SIGNATURE, :LOCAL_ENTRY_STATIC_HEADER_LENGTH, :LOCAL_ENTRY_TRAILING_DESCRIPTOR_LENGTH, :VERSION_MADE_BY, :VERSION_NEEDED_TO_EXTRACT, :VERSION_NEEDED_TO_EXTRACT_ZIP64, :FILE_TYPE_FILE, :FILE_TYPE_DIR, :FILE_TYPE_SYMLINK, :FSTYPE_FAT, :FSTYPE_AMIGA, :FSTYPE_VMS, :FSTYPE_UNIX, :FSTYPE_VM_CMS, :FSTYPE_ATARI, :FSTYPE_HPFS, :FSTYPE_MAC, :FSTYPE_Z_SYSTEM, :FSTYPE_CPM, :FSTYPE_TOPS20, :FSTYPE_NTFS, :FSTYPE_QDOS, :FSTYPE_ACORN, :FSTYPE_VFAT, :FSTYPE_MVS, :FSTYPE_BEOS, :FSTYPE_TANDEM, :FSTYPE_THEOS, :FSTYPE_MAC_OSX, :FSTYPE_ATHEOS, :FSTYPES, :Error, :EntryExistsError, :DestinationFileExistsError, :CompressionMethodError, :EntryNameError, :InternalError, :ZipError, :ZipEntryExistsError, :ZipDestinationFileExistsError, :ZipCompressionMethodError, :ZipEntryNameError, :ZipInternalError] 
+```
+
+# zipruby
+
+```ruby
+> require 'zipruby'
+ => true
+> Zip.constants
+ => [:VERSION, :CREATE, :EXCL, :CHECKCONS, :TRUNC, :FL_NOCASE, :FL_NODIR, :FL_COMPRESSED, :FL_UNCHANGED, :CM_DEFAULT, :CM_STORE, :CM_SHRINK, :CM_REDUCE_1, :CM_REDUCE_2, :CM_REDUCE_3, :CM_REDUCE_4, :CM_IMPLODE, :CM_DEFLATE, :CM_DEFLATE64, :CM_PKWARE_IMPLODE, :CM_BZIP2, :EM_NONE, :EM_TRAD_PKWARE, :NO_COMPRESSION, :BEST_SPEED, :BEST_COMPRESSION, :DEFAULT_COMPRESSION, :Archive, :File, :Stat, :Error] 
+```
+
+# archive/zip
+
+```ruby
+> require 'archive/zip'
+ => true
+> Archive::Zip.constants
+ => [:Codec, :DataDescriptor, :Error, :EntryError, :ExtraFieldError, :IOError, :UnzipError, :ExtraField, :Entry, :EOCD_SIGNATURE, :DS_SIGNATURE, :Z64EOCD_SIGNATURE, :Z64EOCDL_SIGNATURE, :CFH_SIGNATURE, :LFH_SIGNATURE, :DD_SIGNATURE] 
+```

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# can't use pry on old rubies or on rubinius
+if RUBY_VERSION.to_f >= 2.0 && RUBY_ENGINE == 'ruby'
+  gem 'pry', :require => false
+  gem 'pry-byebug', :require => false
+  gem 'guard-rspec', :require => false
+end
+
+# rubyzip requires ruby >= 1.9.2
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("1.9.2")
+  gem 'rubyzip', '~> 1.1.6', :require => nil, :platforms => :ruby
+  gem 'zip-zip', '~>0.3', :require => nil, :platforms => :ruby
+end
+
+gem 'zipruby', '0.3.6', :require => nil, :platforms => :ruby
+gem 'archive-zip', '~> 0.7.0', :require => nil

data/Guardfile

@@ -0,0 +1,77 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Matthew Nielsen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,294 @@
+[![Build Status](https://travis-ci.org/xunker/multi_zip.png?branch=master)](https://travis-ci.org/xunker/multi_zip)
+# [MultiZip](https://github.com/xunker/multi_zip)
+
+MultiZip is a Ruby Gem that abstracts other zipping/unzipping gems. It
+automatically detects what gems are available and provides a consistent
+interface regardless of which is being used. This allows for code that is more
+portable and helps to avoid namespace collisions (zipruby vs. rubyzip for example)
+and other implementation restrictions (MRI vs. Jruby, Unix vs. Windows, etc,).
+
+It currently supports `.zip` archives only. See TODO for info on others.
+
+MultiZip provides a very small and focused set of functions:
+
+ * Create a new zip archive or open existing one.
+ * Add files to a archive from using content from a variable.
+ * Read files from a archive in to a variable.
+ * Extract files from an archive to a local file.
+ * List files contained in an archive.
+ * Delete files from an archive.
+ * Get information for a file in an archive. (Pending TODO)
+ * Add a local file to an archive. (Pending TODO).
+
+It is meant for most common zip/unzip tasks. For anything more
+complicated than these basics, you should use a specific (un)zipping library
+instead.
+
+Rubies supported (see [CI status](https://travis-ci.org/xunker/multi_zip) for more detail):
+  * MRI 2.x.x, 1.9.3, 1.8.7 and REE.
+  * Jruby
+  * Rubinius 2
+
+For information about which backend gems work in which ruby, see [Supported Backend Gems](#supported-backend-gems).
+
+This work is inspired by [multi_json](https://github.com/intridea/multi_json)
+and [multi_xml](https://github.com/sferik/multi_xml). Work began while I was
+visiting Japan in 2014 and is dedicated to the Rubyists of
+[Asukusa.rb](https://asakusarb.doorkeeper.jp/) and
+[John Mettraux](https://twitter.com/jmettraux).
+
+## Installation
+
+Do the standard dance: Either add `gem 'multi_zip'` to your Gemfile or run
+`gem install multi_zip`.
+
+__IMPORTANT NEXT STEP:__ You will also need a zip backend gem installed and
+required. See `Supported Backends` for of which ones can be used.
+
+## Getting started
+
+`multi_zip` will try to use the available gem backends in the following order:
+
+  * rubyzip
+  * archive/zip
+  * zipruby
+
+If no usable backends are loaded a `MultiZip::NoSupportedBackendError` will be
+raised for any operation.
+
+If you have multiple gems available and want to choose your backend, you can
+do that in the initializer:
+
+```ruby
+zip = MultiZip.new(filename, backend: :rubyzip) }
+```
+
+..or by calling `#backend=` on a MultiZip instance:
+
+```ruby
+zip = MultiZip.new(filename)
+zip.backend = :rubyzip
+```
+
+You can see what backends are supported:
+
+```ruby
+> MultiZip.supported_backends
+ => [:rubyzip, :archive_zip, :zipruby]
+```
+
+You can also check which of these supported backends is currently available:
+
+```ruby
+> MultiZip.available_backends
+ => [] 
+> require 'archive/zip'
+ => true 
+> MultiZip.available_backends
+ => [:archive_zip] 
+> require 'zip'
+ => true 
+> MultiZip.available_backends
+ => [:rubyzip, :archive_zip]
+```
+
+### Examples
+
+For all the examples below, assume this:
+```ruby
+zip = MultiZip.new('/path/to/archive.zip')
+```
+
+#### List files in a zip archive
+
+Response array of file names within the archive.
+
+```ruby
+zip.list_members
+# => [
+#  '/path/inside/archive/to/file_1.txt',
+#  '/path/inside/archive/to/file_2.txt'
+# ]
+```
+
+#### Read file from zip archive
+
+```ruby
+file = zip.read_member('/path/inside/archive/to/file.txt')
+# => "This is the content of the file from the archive."
+```
+
+#### Read multiple files from zip archive
+
+```ruby
+files = zip.read_members([
+  '/path/inside/archive/to/file_1.txt',
+  '/path/inside/archive/to/file_2.txt'
+])
+# => ["File one content.", "File two content."]
+```
+
+#### Extract file from zip archive to filesystem path
+
+```ruby
+file = zip.extract_member(
+  '/path/inside/archive/to/file.txt',
+  'path/on/local/filesystem/file.txt'
+)
+# => 'path/on/local/filesystem/file.txt'
+```
+
+#### Write file to zip archive from string
+
+```ruby
+zip.write_member('/path/inside/archive/to/file.txt', 'File one content.')
+# => true
+```
+
+#### Remove a file from a zip archive
+
+```ruby
+file = zip.remove_member('/path/inside/archive/to/file.txt')
+# => true
+```
+
+#### Remove multiple files from a zip archive
+
+```ruby
+file = zip.remove_members([
+  '/path/inside/archive/to/file_1.txt',
+  '/path/inside/archive/to/file_2.txt'
+])
+# => true
+```
+
+#### Creating a new instance and passing a block 
+
+`.new` can accept a block:
+
+```ruby
+MultiZip.new('/path/to/archive.zip') do |archive|
+  # commands
+end
+```
+
+## Supported backend gems
+
+  * [rubyzip](https://rubygems.org/gems/rubyzip)
+    - Works in MRI 1.9.3 and 2.x.x.
+    - Gem doesn't support MRI 1.8.7, Jruby or Rubinius.
+  * [archive-zip](https://rubygems.org/gems/archive-zip)
+    - Works in all MRI, Jruby and Rubinius.
+  * [zipruby](https://rubygems.org/gems/zipruby)
+    - Works in all MRI.
+    - Gem doesn't support Jruby or Rubinius.
+
+Planned for the future:
+
+  * [archive](https://rubygems.org/gems/archive)
+  * [unix_utils](https://rubygems.org/gems/unix_utils)
+  * Other archive formats like gzip, bzip2, 7zip, tar, etc.
+  * Jruby-specific gems
+  * Others (please suggest them in a [new issue](https://github.com/xunker/multi_zip/issues/new))
+
+## Notes
+
+#### No `#save` method?
+
+You'll notice that there is no `#save` method. All changes are made to the
+archive immediately when the given method is called. If there are errors
+writing to an archive, an exception is raised immediately.
+
+#### Archive objects are not kept open between method calls
+
+The underlying archive object from the backend gem is not kept open open in
+memory. That means when you call a method like `#read_member` the archive is
+opened, the file is read and the archive is closed. If you do that method
+twice, that cycle happens two times.
+
+While this *is* inefficient and *may* be slow for large archives, the benefits are a simplified interface and normalized memory usage.
+
+This behaviour is likely to change in future versions; see the below section
+that talks about the `#close` method for more information.
+
+#### `#close` method is currently a non-op
+ 
+You'll notice that there is a `#close` method, but you may not know that it
+doesn't yet do anything since the underlying archive is not kept open between
+method calls.
+
+However, you should still use `#close` where appropriate since this
+behaviour is likely to change in the future.
+
+#### Support for other Rubies
+
+Supporting MRI, Jruby and Rubinius covers 95% of the production-ruby market.
+However, In the future I plan on **trying** to support:
+
+  * maglev
+  * ironruby
+  * macruby
+
+The current travis-ci configuration only tests on Linux. Adding macruby
+support also means testing on OS X. I would like to one-day test with MRI, Ironruby and Jruby on Windows.
+
+MultiZip is written in pure ruby and so it should be able to run on any
+runtime that is compatible with MRI 1.8.7; however, the backend gems it uses
+may or may not work on every platform -- which is one of the reasons this
+gem exists in the first place! One day I would like to support backend gems
+that are specific to Jruby/Java and Windows.
+  
+## TODO
+
+Most important things, in order of importance:
+
+  * #add_member: add file to archive from filesystem (new method).
+  * Document exceptions raised, what they mean and how to use them.
+  * Add inline docs for methods.
+  * support *nix zip(1L)/unzip(1L) without needing backend gem (with warning).
+
+Other things that need to be done, in no particular order:
+
+  * Add support for more backends.
+  * Support for backend gems to process other formats (gzip, bzip2, 7zip, tar, etc).
+  * Keep the backend archive open between method calls.
+  * Add soak tests for memory usage once archived are kept open.
+  * Ensure #close is executed when MultiZip instance goes out of scope.
+  * Option to overwrite and existing archive instead of adding to it.
+  * #extract_member: extract file to path using original member name.
+  * #write_member: support for reading from IO streams.
+  * test with different majour versions of current supported backends.
+  * Standardize Exception classes and when to raise them.
+  * #read_*, #extract_* and #write_* methods should accept a block.
+  * #extract_members: extract multiple files with one command (new method).
+  * #write_member: add entire directory (recursively or not) to archive.
+  * #write_members: add multiple files by wildcard (new method).
+  * #add_members: add multiple files to archive from filesystem (new method).
+  * #remove_members: remove multiple member files from the archive (new_method).
+  * #read_members: read multiple files wildcard.
+  * #read_members: read multiple files via prefix as #list_members does.
+  * #extract_members: extract multiple files via prefix as #list_members does (new method).
+  * #extract_members: extract multiple files wildcard (new method).
+  * #member_info: return information (name, size, etc) about member (new method).
+  * #read_member_stream: return member as IO Stream to keeping large amounts of data in memory (new method).
+  * Write guide to show others how they can add their own backends gems.
+  * #member_type: return the type of the member (new method).
+  * #member_exists?: accept an argument to specify the file type (file, dir, symlink, etc).
+  * Soak-test each backend to find memory leaks.
+
+Things that I'd **like** to do, but that are probably not realistic because
+they cannot be sufficiently abstracted across all backend gems:
+
+  * Ability to set location and compression format and level of archive.
+  * Ability to set compression format and level of individual members (for Epub compatibility).
+  * Ability to set archive location of individual members (for Epub compatibility).
+  * Support creating, reading from and writing to password-protected or encrypted archives.
+
+## Contributing
+
+1. Fork it ( https://github.com/xunker/multi_zip/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Ensure existing tests pass and add tests to cover any new functionality
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+require "rspec/core/version"
+
+task :default => :spec
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec, :default) do |t|
+  t.ruby_opts = %w[-w]
+end

data/lib/multi_zip/backend/archive_zip.rb

@@ -0,0 +1,111 @@
+module MultiZip::Backend::ArchiveZip
+  BUFFER_SIZE = 8192
+
+  def read_member(member_path, options = {})
+    archive_operation do |zip|
+      member = zip.find{|m| m.zip_path == member_path}
+      if member && member.file?
+        return member.file_data.read.to_s
+      else
+        zip.close
+        member_not_found!(member_path)
+      end
+    end
+  end
+
+  def list_members(prefix=nil, options={})
+    archive_operation do |zip|
+      zip.entries.map(&:zip_path).select{|n|
+        prefix ? n =~ /^#{prefix}/ : true
+      }.sort
+    end
+  end
+
+  def write_member(member_path, member_contents, options = {})
+    # archive/zip is really focused on adding content from the file system so
+    # instead of hacking around with a non-public API that may change in the
+    # future, we will just use tempfiles and let it read from disk like the
+    # documentation says.
+    tempfile = Tempfile.new('multizip_member')
+    tempfile.write(member_contents)
+    tempfile.close
+    
+    zip = Archive::Zip.new(@filename, :w)
+    new_entry = Archive::Zip::Entry.from_file(tempfile.path, :zip_path => member_path)
+    zip.add_entry(new_entry)
+
+    # From the docs: The #close method must be called in order to save any
+    # modifications to the archive.  Due to limitations in the Ruby finalization
+    # capabilities, the #close method is _not_ automatically called when this
+    # object is garbage collected.  Make sure to call #close when finished with
+    # this object.
+    zip.close
+    true
+  ensure
+    if defined?(tempfile)
+      tempfile.delete
+    end
+  end
+
+  def extract_member(member_path, destination_path, options = {}) 
+    archive_operation do |zip|
+      member = zip.find{|m| m.zip_path == member_path}
+      if member && member.file?
+        output_file = ::File.new(destination_path, 'wb')
+        while chunk = member.file_data.read(BUFFER_SIZE)
+          output_file.write chunk
+        end
+        output_file.close
+        return destination_path
+      else
+        zip.close
+        member_not_found!(member_path)
+      end
+    end
+  end
+
+  def remove_member(member_path, options = {})
+    remove_members([member_path], options)
+  end
+
+  def remove_members(member_paths, options = {})
+    archive_exists!
+    member_paths.each do |member_path|
+      exists!(member_path)
+    end
+    
+    # archive-zip doesn't have the #remove_entry method any more, so we do
+    # this in a really slow way: we dump the entire dir to the filesystem,
+    # delete `member_path` and zip the whole thing up again.
+    
+    Dir.mktmpdir do |tmp_dir|
+      Archive::Zip.extract(@filename, tmp_dir)
+
+      member_paths.each do |member_path|
+        FileUtils.rm("#{tmp_dir}/#{member_path}")
+      end
+      
+      # create a tempfile and immediately delete it, we just want the name.
+      tempfile = Tempfile.new(['multizip_temp', '.zip'])
+      tempfile_path = tempfile.path
+      tempfile.close
+      tempfile.delete
+
+      Archive::Zip.archive(tempfile_path, "#{tmp_dir}/.")
+      FileUtils.mv(tempfile_path, @filename)
+    end
+
+    true
+  end
+
+private
+
+  def archive_operation(mode = :r) # mode is either :r or :w
+    archive_exists!
+    Archive::Zip.open(@filename, mode) do |zip|
+      yield(zip)
+    end
+  rescue Archive::Zip::UnzipError => e
+    raise MultiZip::InvalidArchiveError.new(@filename, e)
+  end
+end

data/lib/multi_zip/backend/rubyzip.rb

@@ -0,0 +1,73 @@
+module MultiZip::Backend::Rubyzip
+  BUFFER_SIZE = 8192
+  def read_member(member_path, options = {})
+    read_operation do |zip_file|
+      if member = zip_file.glob(member_path).first
+        member.get_input_stream.read
+      else
+        zip_file.close
+        member_not_found!(member_path)
+      end
+    end
+  end
+
+  def list_members(prefix=nil, options={})
+    read_operation do |zip_file|
+      zip_file.map(&:name).select{|n| prefix ? n =~ /^#{prefix}/ : true}.sort
+    end
+  end
+
+  def write_member(member_path, member_contents, options = {})
+    flags = (File.exists?(@filename) ? nil : Zip::File::CREATE)
+
+    Zip::File.open(@filename, flags) do |zipfile|
+      zipfile.get_output_stream(member_path) do |os|
+        os.write member_contents
+      end
+    end
+  end
+
+  def extract_member(member_path, destination_path, options = {})
+    read_operation do |zip_file|
+      if member = zip_file.glob(member_path).first
+        stream = member.get_input_stream
+
+        output_file = ::File.new(destination_path, 'wb')
+
+        while chunk = stream.read(BUFFER_SIZE)
+          output_file.write chunk
+        end
+
+        output_file.close
+      else
+        zip_file.close
+        member_not_found!(member_path)
+      end
+    end
+    destination_path
+  end
+
+  def remove_member(member_path, options = {})
+    archive_exists!
+    exists!(member_path)
+    Zip::File.open(@filename) do |zipfile|
+      zipfile.remove(member_path)
+    end
+  end
+
+private
+
+  def read_operation(&blk)
+    archive_exists!
+    Zip::File.open(@filename) do |zip_file|
+      yield(zip_file)
+    end
+  rescue Zip::Error => e
+    # not the best way to detect the class of error.
+    if e.message.match('Zip end of central directory signature not found')
+      raise MultiZip::InvalidArchiveError.new(@filename, e)
+    else
+      raise
+    end
+  end
+end