archive-tar 0.9.0

data/lib/archive/tar.rb

@@ -0,0 +1,110 @@
+module Archive #:nodoc:
+end
+
+#
+# == Extract Options
+#
+# * <tt>:permissions</tt> - If set to <tt>:preserve</tt>, then the Reader will
+#   attempt to chown and chmod the extracted to files to match the mode, UID
+#   and GID stored in the archive.  For every other value, UID and GID will be
+#   taken from the executing user, and mode from that user's <tt>umask</tt>.
+#
+#   <b>Note:</b> on most operating systems (notably UNIX/Linux) the only user
+#   with rights to change ownership of files and directory is the <tt>root</tt>
+#   user.
+#
+# == Archive Options
+#
+# * <tt>:compression</tt> - If set to <tt>:gzip</tt>, then the Reader will
+#   decompress the tar file on-the-fly (without any temp files) as it extracts
+#   the tarred files.  For every other value, no decompression is done.
+#   <i>Bzip2 compression is not yet supported</i>.
+#
+module Archive::Tar
+	# :stopdoc:
+	UNIX_VERBOSE = Proc.new { |s, _|
+		if (s[:type] == :link)
+			print 'h'
+		else
+			print '-'
+		end
+		[ (s[:mode] & 0700) >> 6, (s[:mode] & 0070) >> 3, (s[:mode] & 0007) ].each do |p|
+			print p & 04 == 04 ? 'r' : '-'
+			print p & 02 == 02 ? 'w' : '-'
+			print p & 01 == 01 ? 'x' : '-'
+		end
+		print ' '
+		print "#{s[:user]}/#{s[:group]}".ljust(16, ' ')
+		print s[:size].to_s.rjust(8,' ')
+		print ' '
+		print Time.at(s[:mtime]).strftime("%Y-%m-%d %H:%M")
+		print ' '
+		print s[:path]
+		if (s[:type] == :link)
+			print ' link to '
+			print s[:dest]
+		end
+		puts
+	}
+	# :startdoc:
+
+	class << self
+		# 
+		# Extract a tar archive (+source_file+) into +dest_dir+.  +source_file+
+		# must exist and the executing user must be able to read it.
+		# Additionally, +dest_dir+ must exist, and the executing user must be
+		# allowed to write to it.
+		#
+		# +options+ is an optional hash of parameters that influence the nature
+		# of the extraction.  See Extract Options and Archive Options (above)
+		# for information on possible values.
+		#
+		def extract(source_file, dest_dir, options = {})
+			Reader.new(source_file, options).extract(dest_dir, options)
+		end
+
+		#
+		# Creates a new tar archive in +dest_file+.  A list of paths to store in the
+		# archive should be passed next.  The last argument can optionally be a hash
+		# of options that will dictate how the archive is created (see Archive
+		# Options, above).
+		#
+		# Example:
+		#
+		#   Archive::Tar.create(
+		#     '~/ruby.tar.gz',       # Where to put the archive
+		#     Dir["~/code/**/*.rb"], # What to tar up
+		#     :compression => :gzip, # Gzip it, to save some space
+		#   )
+		#
+		def create(dest_file, filenames = [], options = {})
+			Writer.new(filenames).write(dest_file, options)
+		end
+
+		#
+		# Cycle through the entries in a tar archive, and pass each entry to a
+		# caller-supplied block.  This is the easiest way to emulate the <tt>-t</tt>
+		# option to the canonical UNIX <tt>tar</tt> utility.
+		#
+		# Each time +block+ is invoked, it will be passed a symbolic-key hash of the
+		# header information (owner, size, last modification time, etc.) and the
+		# contents of the file.  For all file types except a normal file, contents 
+		# will be nil.
+		#
+		# To list the path names of all entries in an archive:
+		#
+		#   Archive::Tar.traverse('ruby.tar.gz', :compression => :gzip) do |header, contents|
+		#     puts header[:path]
+		#   end
+		#
+		def traverse(source_file, options = {}, &block) # :yields: header, contents
+			block ||= UNIX_VERBOSE
+			Reader.new(source_file, options).each(&block)
+		end
+	end
+end
+
+require 'archive/tar/format'
+require 'archive/tar/reader'
+require 'archive/tar/writer'
+require 'archive/tar/stat'

data/lib/archive/tar/format.rb

@@ -0,0 +1,110 @@
+class Archive::Tar::Format # :nodoc:
+	DEC_TYPES = {
+		'0'  => :file,
+		"\0" => :file,
+		'1'  => :link,
+		'2'  => :symlink,
+		'3'  => :character,
+		'4'  => :block,
+		'5'  => :directory,
+		'6'  => :fifo,
+		'7'  => :contiguous
+	}
+
+	ENC_TYPES = {
+		:file       => '0',
+		:link       => '1',
+		:symlink    => '2',
+		:character  => '3',
+		:block      => '4',
+		:directory  => '5',
+		:fifo       => '6',
+		:contiguous => '7'
+	}
+
+
+	class << self
+		def next_block(io)
+			block = ''
+			loop do
+				block = io.read(512)
+				return block unless block == "\0" * 512
+				return nil if io.eof?
+			end
+		end
+
+		def unpack_header(block)
+			h = block.unpack("Z100 Z8 Z8 Z8 Z12 Z12 A8 a Z100 Z6 Z2 Z32 Z32 Z8 Z8 Z155")
+			{
+				:path  => h.shift,
+				:mode  => h.shift.oct,
+				:uid   => h.shift.oct,
+				:gid   => h.shift.oct,
+				:size  => h.shift.oct,
+				:mtime => Time.at(h.shift.oct),
+				:cksum => h.shift.oct,
+				:type  => DEC_TYPES[h.shift],
+				:dest  => h.shift,
+				:ustar => h.shift.strip == 'ustar',
+				:uvers => h.shift.strip,
+				:user  => h.shift,
+				:group => h.shift,
+				:major => h.shift.oct,
+				:minor => h.shift.oct,
+				:pre   => h.shift
+			}
+		end
+
+		def pack_header(h)
+			packed = [
+				h[:path],
+				"%07o"  % h[:mode],
+				"%07o"  % h[:uid],
+				"%07o"  % h[:gid],
+				"%011o" % h[:size],
+				"%011o" % h[:mtime].to_i,
+				'',
+				ENC_TYPES[h[:type]],
+				h[:dest],
+				h[:ustar] ? "ustar" : '',
+				"00",
+				h[:user],
+				h[:group],
+				"%07o" % h[:major],
+				"%07o" % h[:minor],
+				h[:pre]
+			].pack("a100 a8 a8 a8 a12 a12 A8 a a100 a6 a2 a32 a32 a8 a8 a155 x12")
+			packed[148, 7] = "%06o\0" % packed.unpack("C*").inject { |total, byte| total + byte }
+			packed
+		end
+
+		def stat(path, inodes)
+			lstat = File.lstat(path)
+			dest = lstat.symlink? ? File.readlink(path) : inodes[lstat.ino]
+
+			inodes[lstat.ino] ||= path
+
+			size = lstat.size
+			size = 0 if dest || !lstat.file?
+
+			{
+				:path  => path[0,1] == '/' ? path[1, path.size - 1] : path,
+				:mode  => lstat.mode,
+				:uid   => lstat.uid,
+				:gid   => lstat.gid,
+				:size  => size,
+				:mtime => lstat.mtime.to_i,
+				:type  => (lstat.file? && dest ? :link : lstat.tar_type),
+				:dest  => dest.to_s,
+
+				:ustar => true,
+				:uvers => "00",
+				:user  => Etc.getpwuid(lstat.uid).name,
+				:group => Etc.getgrgid(lstat.gid).name,
+				:major => lstat.dev_major.to_i,
+				:minor => lstat.dev_minor.to_i,
+				:pre   => '', # FIXME: implement
+			}
+		end
+	end
+end

data/lib/archive/tar/reader.rb

@@ -0,0 +1,67 @@
+require 'zlib'
+require 'fileutils'
+
+class Archive::Tar::Reader
+	def initialize(source, options = {})
+		@source = source
+
+		@options = {
+			:compression => :none
+		}.merge(options)
+	end
+
+	def each(full = false, &block)
+		case @source
+			when IO: parse(@source, full); @source.rewind
+			else     File.open(@source, 'r') { |f| parse(f, full) }
+		end
+
+		@index.each { |path| yield *(@records[path]) }
+	end
+
+	def extract(dest, options = {})
+		options = {
+			:permissions => nil
+		}.merge(options)
+
+		raise "No such directory: #{dest}" unless File.directory?(dest)
+
+		each(true) do |header, body|
+			path = File.join(dest, header[:path])
+			FileUtils.mkdir_p( File.dirname(path) )
+
+			case header[:type]
+				when :file:       File.open(path, 'w') { |fio| fio.write(body) }
+				when :directory:  FileUtils.mkdir(path)
+				when :link:       File.link( File.join(dest, header[:dest]), path )
+				when :symlink:    File.symlink( header[:dest], path )
+			end
+
+			if options[:permissions] == :preserve && !File.symlink?(path)
+				File.chmod header[:mode], path
+				File.chown header[:uid].to_i, header[:gid].to_i, path
+			end
+		end
+	end
+
+	def parse(io, full = false)
+		@index = []
+		@records = {}
+
+		io = Zlib::GzipReader.new(io) if @options[:compression] == :gzip
+
+		until io.eof?
+			hblock = Archive::Tar::Format.next_block(io)
+			break unless hblock
+
+			header = Archive::Tar::Format.unpack_header(hblock)
+			path = header[:path]
+			size = header[:size]
+
+			@index << path
+			@records[path] = [ header, io.read(size % 512 == 0 ? size : size + (512 - size % 512)) ]
+			@records[path][1] = nil unless full
+		end
+	end
+	private :parse
+end

data/lib/archive/tar/stat.rb

@@ -0,0 +1,16 @@
+module Archive # :nodoc:
+	module Tar
+		module Stat # :nodoc:
+			def tar_type
+				case self.ftype
+					when 'file':             :file
+					when 'directory':        :directory
+					when 'blockSpecial':     :block
+					when 'characterSpecial': :character
+					when 'link':             :symlink
+				end
+			end
+		end
+	end
+end
+File::Stat.send(:include, Archive::Tar::Stat)

data/lib/archive/tar/writer.rb

@@ -0,0 +1,51 @@
+require 'etc'
+require 'zlib'
+
+class Archive::Tar::Writer
+	def initialize(filenames)
+		@inodes = {}
+		@records = {}
+		@index = []
+		filenames.each { |path| self << path }
+	end
+
+	def <<(filename)
+		@index << filename
+		@records[filename] = Archive::Tar::Format.stat(filename, @inodes)
+		if File.directory?(filename)
+			Dir.open(filename) do |dh|
+				dh.entries.each do |file|
+					self << File.join(filename, file) unless [".",".."].include? file
+				end
+			end
+		end
+	end
+
+	def write(dest, options = {})
+		if dest.is_a? IO
+			write_to(dest, options)
+		else
+			File.open(dest, 'w') { |io| write_to(io, options) }
+		end
+	end
+
+	def write_to(io, options = {})
+		options = {
+			:compression => :none
+		}.merge(options)
+
+		io = Zlib::GzipWriter.new(io) if options[:compression] == :gzip
+		
+		@index.each do |path|
+			stat = @records[path]
+			io.write Archive::Tar::Format.pack_header(stat)
+
+			File.open(path, 'r') do |fio|
+				io.write [fio.read(512)].pack("Z512") until fio.eof?
+			end if stat[:dest].empty?
+		end
+		io.write("\0" * 1024)
+		io.close
+	end
+	private :write_to
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: archive-tar
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- James R Hunt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-04 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: james@niftylogic.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/archive/tar.rb
+- lib/archive/tar/reader.rb
+- lib/archive/tar/writer.rb
+- lib/archive/tar/format.rb
+- lib/archive/tar/stat.rb
+has_rdoc: true
+homepage: http://gems.niftylogic.net/activedirectory
+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: archive-tar
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An interface library for reading and writing UNIX tar files.
+test_files: []
+