multi_zip 0.1.3

data/lib/multi_zip/backend/zipruby.rb

@@ -0,0 +1,94 @@
+module MultiZip::Backend::Zipruby
+  BUFFER_SIZE = 8192
+  def read_member(member_path, options = {})
+    # detect if called asked for a directory instead of a file
+    member_not_found!(member_path) if member_path =~ /\/$/
+    read_operation do |ar|
+      exists_in_archive!(ar, member_path)
+      ar.fopen(member_path) {|member| member.read}
+    end
+  end
+
+  def list_members(prefix=nil, options={})
+    read_operation do |zip|
+      list = []
+      zip.num_files.times do |i|
+        list << zip.get_name(i)
+      end
+      list.select{|n| prefix ? n =~ /^#{prefix}/ : true}.sort
+    end
+  end
+
+  def write_member(member_path, member_contents, options = {})
+    flags = (File.exists?(@filename) ? nil : Zip::CREATE)
+    Zip::Archive.open(@filename, flags) do |ar|
+      if ar.map(&:name).include?(member_path)
+        ar.replace_buffer(member_path, member_contents)
+      else
+        ar.add_buffer(member_path, member_contents)
+      end
+    end
+    true
+  end
+
+  def extract_member(member_path, destination_path, options = {})
+    # detect if called asked for a directory instead of a file
+    member_not_found!(member_path) if member_path =~ /\/$/
+    read_operation do |ar|
+      exists_in_archive!(ar, member_path)
+      output_file = ::File.new(destination_path, 'wb')
+
+      ar.fopen(member_path) do |member|
+        while chunk = member.read(BUFFER_SIZE)
+          output_file.write chunk
+        end
+      end
+
+      output_file.close
+    end
+    destination_path
+  end
+
+  def remove_member(member_path, options = {})
+    archive_exists!
+    Zip::Archive.open(@filename) do |ar|
+      exists_in_archive!(ar, member_path)
+      ar.fdelete(ar.locate_name(member_path))
+    end
+    true
+  end
+
+private
+
+  # NOTE: Zip::Archive#locate_name return values
+  # -1 if path not found
+  # 0  if path is a directory
+  # 2  if path is a file
+  #
+  # for a directory to be found it must include the trailing slash ('/').
+
+  def exists_in_archive?(zip, member_path)
+    zip.locate_name(member_path).to_i >= 0 # will find files or dirs.
+  end
+
+  def exists_in_archive!(zip, member_path)
+    unless exists_in_archive?(zip, member_path)
+      zip.close
+      raise member_not_found!(member_path)
+    end
+  end
+
+  def read_operation(&blk)
+    archive_exists!
+    Zip::Archive.open(@filename) do |ar|
+      yield(ar)
+    end
+  rescue Zip::Error => e
+    # not the best way to detect the class of error.
+    if e.message.match('Not a zip archive')
+      raise MultiZip::InvalidArchiveError.new(@filename, e)
+    else
+      raise
+    end
+  end
+end

data/lib/multi_zip/errors.rb

@@ -0,0 +1,35 @@
+class MultiZip
+  class BaseError < RuntimeError; end
+  
+  class NoSupportedBackendError < BaseError; end
+
+  class ArchiveError < BaseError
+    attr_reader :archive_filename, :original_exception
+    def initialize(archive_filename, original_exception=nil)
+      @archive_filename = archive_filename
+      @original_exception = original_exception
+    end
+    def message
+      "Archive \"#{@archive_filename}\" error: #{@original_exception.message}"
+    end
+  end
+
+  class InvalidArchiveError < ArchiveError; end
+  class ArchiveNotFoundError < ArchiveError
+    def message
+      "Archive \"#{@archive_filename}\" not found"
+    end
+  end
+
+  class MemberError < BaseError
+    attr_reader :member_path
+    def initialize(member_path)
+      @member_path = member_path
+    end
+    def message
+      "Member \"#{@member_path}\" not found."
+    end
+  end
+
+  class MemberNotFoundError < MemberError; end
+end

data/lib/multi_zip/version.rb

@@ -0,0 +1,3 @@
+class MultiZip
+  VERSION = "0.1.3"
+end

data/lib/multi_zip.rb

@@ -0,0 +1,195 @@
+class MultiZip
+  module Backend; end # populated later by #extend
+
+  attr_reader :filename
+
+  BACKEND_PREFERENCE = [ :rubyzip, :archive_zip, :zipruby ]
+  BACKENDS = {
+    :rubyzip => {
+      :fingerprints => [
+        ['constant', lambda { defined?(Zip::File) } ],
+        [nil, lambda { defined?(Zip::Archive) }]
+      ],
+      :constant => lambda { MultiZip::Backend::Rubyzip }
+    },
+    :archive_zip => {
+      :fingerprints => [
+        ['constant', lambda { defined?(Archive::Zip) } ]
+      ],
+      :constant => lambda { MultiZip::Backend::ArchiveZip }
+    },
+    :zipruby => {
+      :fingerprints => [
+        ['constant', lambda { defined?(Zip::File) } ],
+        ['constant', lambda { defined?(Zip::Archive) }]
+      ],
+      :constant => lambda { MultiZip::Backend::Zipruby }
+    }
+  }
+
+  def initialize(filename, options = {})
+    @filename = filename
+
+    self.backend = if b_end = options.delete(:backend)
+      b_end
+    else
+      default_backend
+    end
+
+    if block_given?
+      yield(self)
+    end
+  end
+
+  def backend
+    @backend ||= default_backend
+  end
+
+  def backend=(backend_name)
+    return if backend_name.nil?
+    if BACKENDS.keys.include?(backend_name.to_sym)
+      @backend = backend_name.to_sym
+      require "multi_zip/backend/#{@backend}"
+      extend BACKENDS[@backend][:constant].call
+      return @backend
+    else
+      raise NoSupportedBackendError, "Not a supported backend. Supported backends are #{BACKENDS.map(&:first).map(&:to_s).sort.join(', ')}"
+    end
+  end
+
+  def self.supported_backends
+    BACKENDS.keys
+  end
+
+  def self.available_backends
+    available = []
+    BACKENDS.each do |name, opts|
+      if opts[:fingerprints].all?{|expectation, lmb| lmb.call == expectation }
+        available << name
+      end
+    end
+    available
+  end
+
+  # Close the archive, if the archive is open.
+  # If the archive is already closed, behave as though it was open.
+  # Expected to always return true.
+  #
+  # This is currently a non-op since the archives are not kept open between
+  # method calls. It is here so users can write code using it to prepare for
+  # when we *do* keep the archives open.
+  #
+  # Currently, this method MUST NOT be overridden.
+  def close
+    return true
+  end
+
+  # Intended to return the contents of a zip member as a string.
+  #
+  # This method MUST be overridden by a backend module.
+  def read_member(member_path, options={})
+    raise NotImplementedError
+  end
+
+  # Intended to return the contents of zip members as array of strings.
+  #
+  # This method MAY be overridden by backend module for the sake of
+  # efficiency, or will call #read_member for each entry in member_paths.
+  def read_members(member_paths, options={})
+    member_paths.map{|f| read_member(f, options) }
+  end
+
+  # Intended to write the contents of a zip member to a filesystem path.
+  #
+  # This SHOULD be overridden by a backend module because this default
+  # will try to read the whole file in to memory before outputting to disk
+  # and that can be memory-intensive if the file is large.
+  def extract_member(member_path, destination_path, options={})
+    warn "Using default #extract_member which may be memory-inefficient"
+    default_extract_member(member_path, destination_path, options)
+  end
+
+  # List members of the zip file. Optionally can specify a prefix.
+  #
+  # This method MUST be overridden by a backend module.
+  def list_members(prefix = nil, options={})
+    raise NotImplementedError
+  end
+
+  # Boolean, does a given member path exist in the zip file?
+  #
+  # This method MAY be overridden by backend module for the sake of
+  # efficiency. Otherwise it will use #list_members.
+  def member_exists?(member_path, options={})
+    list_members(nil, options).include?(member_path)
+  end
+
+  # Write string contents to a zip member file
+  def write_member(member_path, member_content, options={})
+    raise NotImplementedError
+  end
+
+  # Remove a zip member from the archive.
+  # Expected to raise MemberNotFoundError if the member_path was not found in
+  # the archive
+  #
+  # This method MUST be overridden by a backend module.
+  def remove_member(member_path, options={})
+    raise NotImplementedError
+  end
+
+  # Remove multiple zip member from the archive.
+  # Expected to raise MemberNotFoundError if the member_path was not found in
+  # the archive
+  #
+  # This method MAY be overridden by backend module for the sake of
+  # efficiency. Otherwise it will use #remove_member.
+  def remove_members(member_paths, options={})
+    member_paths.map{|f| remove_member(f, options) }.all?
+  end
+
+private
+
+  # Convenience method that will raise ArchiveNotFoundError if the archive
+  # doesn't exist or if the archive path given points to something other than
+  # a file.
+  def archive_exists!
+    unless File.file?(@filename)
+      raise ArchiveNotFoundError.new(@filename)
+    end
+  end
+
+  # Convenience method that will raise MemberNotFoundError if the member doesn't exist.
+  # Uses #member_exists? in whatever form (default or custom).
+  def exists!(member_path)
+    unless member_exists?(member_path)
+      member_not_found!(member_path)
+    end
+    true
+  end
+
+  # Raises MemberNotFoundError
+  def member_not_found!(member_path)
+    raise MemberNotFoundError.new(member_path)
+  end
+
+  def default_extract_member(member_path, destination_path, options={})
+    output_file = ::File.new(destination_path, 'wb')
+    output_file.write(read_member(member_path, options))
+    output_file.close
+    destination_path
+  end
+
+  def default_backend
+    BACKEND_PREFERENCE.each do |name|
+      be = BACKENDS[name]
+      if be[:fingerprints].all?{|expectation, lmb| lmb.call == expectation }
+        return name
+      end
+    end
+    raise NoSupportedBackendError, "No supported backend found: #{BACKEND_PREFERENCE.join(', ')}"
+  end
+end
+
+require "multi_zip/version"
+require "multi_zip/errors"

data/multi_zip.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multi_zip/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "multi_zip"
+  spec.version       = MultiZip::VERSION
+  spec.authors       = ["Matthew Nielsen"]
+  spec.email         = ["xunker@pyxidis.org"]
+  spec.summary       = %q{Abstracts zipping and unzipping using whatever gems are installed, automatically.}
+  spec.description   = %q{Abstracts zipping and unzipping using whatever gems are installed using one consistent API. Provides swappable zipping/unzipping backends so you're not tied to just one gem. Supports rubyzip, archive-zip, zipruby and others.}
+  spec.homepage      = "https://github.com/xunker/multi_zip"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+end