IronDigital-zippy 0.1.1

data/README

@@ -0,0 +1,19 @@
+Zippy.create 'awsum.zip' do |zip|
+  zip['README'] = 'In Soviet Russia, README READSYOU'
+  zip['porn.mpeg'] = File.open('rick astley - never gonna give you up.mpg')
+end
+
+Zippy.list('awsum.zip') #=> ['README', 'porn.mpeg']
+
+Zippy.open('awsum.zip') do |zip|
+  zip['bin/hello_world'] = "#!/usr/bin/env ruby\n\nputs 'hello, zip world'"
+end
+
+
+
+#Your params as a zip
+#It's SAAS!
+require 'sinatra'
+get '/' do
+  Zippy.new{|z| params.each{|k,v| z[k] = v } }.data
+end

data/lib/zippy.rb

@@ -0,0 +1,216 @@
+require 'zip/zip'
+
+class Zippy
+
+  include Enumerable
+  #extend Enumerable
+
+
+  #Make an archive
+  #Filename is optional; if none is provided, a generated, temporary
+  #filename will be used.
+  #If a block is provided, the archive is yielded
+  #Takes an optional second parameter which is a hash of entries that will
+  #be added after initialization
+  def initialize(entries_and_options={})
+    entries_and_options.each{|k,v| send("#{k}=", v) if respond_to?("#{k}=") && k.is_a?(Symbol) }
+    without_autocommit do
+      entries_and_options.each{|k,v| self[k] = v if k.is_a?(String) }
+    end
+    yield self if block_given?
+  end
+
+
+  def each
+    zipfile.each{|e| yield e.name }
+  end
+
+  def size
+    zipfile.size
+  end
+
+  def empty?
+    size.zero?
+  end
+
+  #Returns the full path to all entries in the archive
+  def paths
+    map
+  end
+
+
+  #Read an entry
+  def [](entry)
+    return nil unless include?(entry)
+    zipfile.read(entry)
+  end
+
+  #Add or change an entry with the name +entry+
+  #+contents+ can be a string or an IO
+  def []=(entry, contents)
+    zipfile.get_output_stream entry do |s|
+      if contents.is_a?(String)
+        s.write contents
+      elsif contents.respond_to?(:read)
+        s.write contents.read(1024) until contents.eof?
+      elsif contents.respond_to?(:to_s)
+        s.write contents.to_s
+      else#Not sure these last two are different
+        s.write "#{contents}"
+      end
+    end
+    zipfile.commit if autocommit?
+    true
+  end
+
+
+  #Delete an entry
+  def delete(*entries)
+    entries.each do |entry|
+      zipfile.remove(entry)
+    end
+    zipfile.commit if autocommit?
+    entries
+  end
+
+  #Rename an entry
+  def rename(old_name, new_name)
+    zipfile.rename(old_name, new_name)
+    zipfile.commit if autocommit?
+    old_name
+  end
+
+
+  #Close the archive for writing
+  def close
+    write(filename)
+    zipfile.close
+  end
+
+  #Write the archive to +filename+
+  #If a filename is not provided, it will write
+  #to the default filename (self.filename)
+  def write(filename)
+    return false if empty?
+    zipfile.commit
+    unless filename == self.filename
+      FileUtils.cp(self.filename, filename)
+    end
+    true
+  end
+
+  #Returns the entire archive as a string
+  def data
+    return nil if empty?
+    zipfile.commit
+    File.read(filename)
+  end
+
+
+  def filename
+    @filename ||= random_filename
+  end
+
+  def filename=(filename)
+    rename_file(filename)
+    @filename = filename
+  end
+
+
+  def zipfile
+    @zipfile ||= Zip::ZipFile.new(filename, true)
+  end
+
+
+  #Create a new archive with the name +filename+, populate it
+  #and then close it
+  #
+  #Warning: Will overwrite existing file
+  def self.create(filename, options_and_entries={}, &b)
+    File.unlink(filename) if File.exists?(filename)
+    z = new({:filename => filename}.merge(options_and_entries), &b)
+    z.close
+    z
+  end
+
+  #Works the same as new, but require's an explicit filename
+  #If a block is provided, it will be closed at the end of the block
+  def self.open(filename, options_and_entries={})
+    raise(ArgumentError, "file \"#{filename}\" does not exist") unless File.exists?(filename)
+    z = new({:filename => filename}.merge(options_and_entries))
+    if block_given?
+      yield z
+      z.close
+    end
+    z
+  end
+
+  #Iterate each entry name _and_ its contents in the archive +filename+
+  def self.each(filename)
+    open(filename) do |zip|
+      zip.each do |name|
+        yield name, zip[name]
+      end
+    end
+  end
+
+  #Returns an array of entry names from the archive +filename+
+  #
+  #Zippy.list('my.zip') #=> ['foo', 'bar']
+  def self.list(filename)
+    list = nil
+    open(filename){|z| list = z.paths }
+    list
+  end
+
+  
+  #Read the contents of a single entry in +filename+
+  def self.read(filename, entry)
+    content = nil
+    open(filename){|z| content = z[entry] }
+    content
+  end
+
+
+  def self.[](filename, entry=nil)
+    entry ? read(filename, entry) : list(filename)
+  end
+
+  def self.[]=(filename, entry, content)
+    open(filename){|z| z[entry] = content }
+  end
+
+
+private
+
+  def random_filename
+    File.join(Dir.tmpdir, "zippy_#{Time.now.to_f.to_s}.zip")
+  end
+
+
+  def rename_file(new_name)
+    if @filename && @zipfile && File.exists?(@filename)
+      zipfile.close
+      File.rename(@filename, new_name)
+    end
+    @zipfile = nil #Force reload
+  end
+
+
+  def autocommit?
+    @autocommit.nil? ? true : @autocommit
+  end
+
+  def autocommit=(b)
+    @autocommit = !!b
+  end
+
+  def without_autocommit
+    ac = autocommit?
+    self.autocommit = false
+    yield
+    self.autocommit = ac
+  end
+
+
+end

data/rails/README

@@ -0,0 +1,18 @@
+This plugin adds a template handler for the extension "zipper", so you
+could for example have a view show.zip.zipper which returns a zip file.
+The view file is evaluated as Ruby, inside a Zippy.new{|zip|} block.
+
+Example controller:
+def show
+  @gallery = Gallery.find(params[:id])
+  respond_to do |format|
+    format.html
+    format.zip
+  end
+end
+
+Example view:
+zip['description.txt'] = @gallery.description
+@gallery.photos.each do |photo|
+  zip["photo_#{photo.id}.png"] = File.open(photo.url)
+end

data/rails/init.rb

@@ -0,0 +1,23 @@
+require 'zippy'
+
+Mime::Type.register 'application/zip', :zip
+
+module ::ActionView
+  module TemplateHandlers
+    class Zipper < TemplateHandler
+      include Compilable
+ 
+      def compile(template)
+        "Zippy.new do |zip|" +
+        (template.respond_to?(:source) ? template.source : template) +
+        "end.data"
+      end
+    end
+  end
+end
+
+if defined? ::ActionView::Template and ::ActionView::Template.respond_to? :register_template_handler
+  ::ActionView::Template
+else
+  ::ActionView::Base
+end.register_template_handler(:zipper, ::ActionView::TemplateHandlers::Zipper)

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: IronDigital-zippy
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Tore Darell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: IronDigital-rubyzip
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+    version: 
+description: Zippy reads and writes zip files
+email: toredarell@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/zippy.rb
+- README
+- rails/init.rb
+- rails/README
+has_rdoc: false
+homepage: http://github.com/toretore/zippy
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: rubyzip for dummies
+test_files: []
+