archive-tar2 1.5

data/lib/archive/tar.rb

@@ -0,0 +1,80 @@
+=begin license
+Copyright (c) 2010 Fritz Grimpen
+
+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.
+=end
+
+module Archive
+  module Tar
+    VERSION = "1.5.0"
+    
+    def normalize_path(path)
+      path = path.gsub("\\", "/")
+    
+      while path[-1] == "/"
+        path = path[0..-2]
+      end
+      
+      while path[0] == "/"
+        path = path[1..-1]
+      end
+      
+      solve_path(path.gsub(/[\/]{2,}/, "/"))
+    end
+    
+    def solve_path(path)
+      path_parts = path.split("/")
+      realpath = []
+      
+      path_parts.each do |i|
+        if i == "."
+          next
+        end
+        
+        if i == ".."
+          realpath = realpath[1..-2]
+          realpath = [] if realpath == nil
+          next
+        end
+        
+        realpath << i
+      end
+      
+      realpath.join("/")
+    end
+    
+    def join_path(*files)
+      absolute = files[0][0] == "/"
+      files = files.map do |element|
+        normalize_path element
+      end
+      
+      new_path = files.join("/")
+      new_path = "/" + new_path if absolute
+      
+      new_path
+    end
+  end
+end
+
+require "archive/tar/format.rb"
+require "archive/tar/reader.rb"
+require "archive/tar/writer.rb"
+require "archive/tar/stat.rb"
+require "archive/tar/stream_reader.rb"

data/lib/archive/tar/format.rb

@@ -0,0 +1,147 @@
+=begin license
+Copyright (c) 2010 Fritz Grimpen
+
+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.
+=end
+
+require "archive/tar/stat"
+
+class Archive::Tar::Format
+  DEC_TYPES = {
+    "\0" => :normal,
+    "0" => :normal,
+    "1" => :link,
+    "2" => :symbolic,
+    "3" => :character,
+    "4" => :block,
+    "5" => :directory,
+    "6" => :fifo,
+    "7" => :reserved,
+    "I" => :index,
+    "g" => :pax_global_header
+  }
+
+  ENC_TYPES = DEC_TYPES.invert
+  
+  class << self
+    # Remove all NUL bytes at the end of a string
+    def strip_nuls(string)
+      until string[-1] != "\0"
+        string = string[0..-2]
+      end
+      
+      string
+    end
+  
+    # Transform tar header to Stat
+    def unpack_header(header)
+      new_obj = Archive::Tar::Stat.new
+    
+      new_obj.path = strip_nuls(header[0, 100])
+      new_obj.mode = header[100, 8].oct
+      new_obj.uid = header[108, 8].oct
+      new_obj.gid = header[116, 8].oct
+      new_obj.size = header[124, 12].oct
+      new_obj.mtime = Time.at(header[136, 12].oct)
+      new_obj.checksum = header[148, 8].oct
+      new_obj.type = DEC_TYPES[header[156]]
+      new_obj.dest = strip_nuls(header[157, 100])
+      new_obj.format = header[257, 5] == "ustar" ?
+        ( header[257, 6] == "ustar " ? :gnu : :ustar ) : :other
+      new_obj.user = strip_nuls(header[265, 32])
+      new_obj.group = strip_nuls(header[297, 32])
+      new_obj.major = header[329, 8].oct
+      new_obj.minor = header[337, 8].oct
+      
+      new_obj.path = header[345, 155].strip + new_obj.path if new_obj.ustar?
+      
+      if new_obj.gnu?
+        new_obj.atime = Time.at(header[345, 12].oct)
+        new_obj.ctime = Time.at(header[357, 12].oct)
+      end
+      
+      new_obj
+    end
+    
+    # Detect type of tar file by header
+    def detect_type(header)
+      return :ustar if header[257, 6] == "ustar0"
+      return :gnu if header[257, 6] == "ustar "
+      
+      :other
+    end
+    
+    # Generate checksum with header
+    def calculate_checksum(header)
+      checksum = 0
+      
+      header.each_byte do |byte|
+        checksum += byte
+      end
+      
+      checksum.to_s(8).rjust(6, " ") + "\0 "
+    end
+    
+    # Pack header from Stat
+    def pack_header(header)
+      blob = ""
+      
+      blob += header.path.ljust(100, "\0")
+      blob += header.mode.to_s(8).rjust(8, "0")
+      blob += header.uid.to_s(8).rjust(8, "0")
+      blob += header.gid.to_s(8).rjust(8, "0")
+      blob += header.size.to_s(8).rjust(12, "0")
+      blob += header.mtime.to_i.to_s(8).rjust(12, "0")
+      blob += " " * 8
+      blob += ENC_TYPES[header.type]
+      blob += header.dest.ljust(100, "\0")
+      
+      case header.format
+      when :ustar
+        blob += "ustar\000"
+      when :gnu
+        blob += "ustar  \0"
+      end
+      
+      if header.gnu? || header.ustar?
+        blob += header.user.ljust(32, "\0")
+        blob += header.group.ljust(32, "\0")
+        blob += header.major.to_s(8).rjust(8, "0")
+        blob += header.minor.to_s(8).rjust(8, "0")
+        
+        if header.gnu?
+          blob += header.atime.to_i.to_s(8).rjust(12, "0")
+          blob += header.ctime.to_i.to_s(8).rjust(12, "0")
+        end
+      end
+      
+      pad_length = 512 - blob.bytesize
+      blob += "\0" * pad_length
+      
+      blob[148, 8] = calculate_checksum(blob)
+      
+      blob
+    end
+    
+    # Calculate quantity of blocks
+    def blocks_for_bytes(bytes)
+      bytes % 512 == 0 ? bytes / 512 : (bytes + 512 - bytes % 512) / 512
+    end
+  end
+end

data/lib/archive/tar/reader.rb

@@ -0,0 +1,327 @@
+=begin license
+Copyright (c) 2010 Fritz Grimpen
+
+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.
+=end
+
+require "fileutils"
+require "archive/tar/format"
+
+class Archive::Tar::NoSuchEntryError < RuntimeError
+end
+
+class Archive::Tar::Reader
+  include Archive::Tar
+
+  def initialize(stream, options = {})
+    options = {
+      compression: :auto,
+      tmpdir: "/tmp",
+      block_size: 2 ** 19,
+      read_limit: 2 ** 19,
+      cache: true,
+      cache_size: 16,
+      max_cache_size: 2 ** 19,
+      generate_index: true,
+      use_normalized_paths: true,
+    }.merge(options)
+    
+    if stream.is_a? String
+      stream = File.new(stream)
+    end
+    
+    @options = options
+    @stream = _generate_compressed_stream(stream, options[:compression])
+    @cache_candidates = []
+    @cache = {}
+    
+    build_index if options[:generate_index]
+  end
+  
+  def stream
+    @stream
+  end
+  
+  def index
+    @index
+  end
+  
+  def stat(file, exception = true)
+    if @options[:use_normalized_paths]
+      result = @index[normalize_path(file)]
+    else
+      result = @index[file]
+    end
+    raise NoSuchEntryError.new(file) if result == nil && exception
+    
+    result
+  end
+  
+  def [](file)
+    stat(file, false)
+  end
+  
+  def has_entry?(file)
+    @index.key? file
+  end
+  
+  def entry?(file)
+    has_entry? file
+  end
+  
+  def each(&block)
+    @index.each do |key, value|
+      block.call(*(value))
+    end
+  end
+  
+  def read(name, no_cache = false)
+    header, offset = stat(name)
+    
+    if @options[:cache] && header[:size] <= @options[:max_cache_size] && !no_cache
+      @cache_candidates << name
+      rebuild_cache
+    end
+    
+    if @cache.key? name && !no_cache
+      return @cache[name]
+    end
+    
+    @stream.seek(offset)
+    @stream.read(header[:size])
+  end
+  
+  # Extract all files to /dest/ directory
+  def extract_all(dest, options = {})
+    options = {
+      :preserve => false,
+      :override => false
+    }.merge(options)
+  
+    unless File::exists? dest
+      FileUtils::mkdir_p dest
+    end
+
+    unless File.directory? dest
+      raise "No such directory: #{dest}"
+    end
+
+    @index.each_key do |entry|
+      ndest = File.join(dest, entry)
+      header, offset = @index[entry]
+      
+      _extract(header, offset, ndest, options)
+    end
+  end
+
+  # Extract file from /source/ to /dest/
+  def extract(source, dest, options = {})
+    options = {
+      recursive: true,
+      preserve: false,
+      override: false
+    }.merge(options)
+    unless @index.key? source
+      raise NoSuchEntryError.new(source)
+    end
+
+    header, offset = @index[source]
+    _extract(header, offset, dest, options)
+
+    if header[:type] == :directory && options[:recursive]
+      @index.each_key do |entry|
+        if entry[0, source.length] == source && entry != source
+          extract(entry, File.join(dest, entry.sub(source, "")), options)
+        end
+      end
+    end
+  end
+  
+  # Build new index of files
+  def build_index
+    new_index = {}
+    
+    @stream.rewind
+    
+    until @stream.eof?
+      raw_header = @stream.read(512)
+      break if raw_header == "\0" * 512
+      
+      header = Archive::Tar::Format::unpack_header(raw_header)
+      if @options[:use_normalized_paths]
+        header[:path] = normalize_path(header[:path])
+      end
+      
+      unless header[:type] == :pax_global_header
+        new_index[header[:path]] = [ header, @stream.tell ]
+      end
+      
+      @stream.seek(header[:blocks] * 512, IO::SEEK_CUR)
+    end
+    
+    @index = new_index
+  end
+  
+  protected
+  def rebuild_cache
+    return nil unless @options[:cache]
+    
+    cache_count = {}
+    @cache_candidates.each do |candidate|
+      cache_count[candidate] = 0 unless cache_count.key? candidate
+      cache_count[candidate] += 1
+    end
+    cache_count_sorted = cache_count.sort do |pair_1, pair_2|
+      (pair_1[1] <=> pair_2[1]) * -1
+    end
+    
+    puts cache_count_sorted
+    
+    @cache = {}
+    i = 0
+    cache_count_sorted.each do |tupel|
+      if i >= @options[:cache_size]
+        break
+      end
+      
+      @cache[tupel[0]] = read(tupel[0], true)
+      i += 1
+    end
+  end
+  
+  def export_to_file(offset, length, source, destination)
+    destination = File.new(destination, "w+b") if destination.is_a?(String)
+    
+    if @options[:max_cache_size] >= length && @options[:cache]
+      @cache_candidates << source
+      rebuild_cache
+    end
+    
+    if @cache.key? source
+      destination.write(@cache[source])
+      return true
+    end
+    
+    @stream.seek(offset)
+    
+    if length <= @options[:read_limit]
+      destination.write(@stream.read(length))
+      return true
+    end
+    
+    i = 0
+    while i < length
+      destination.write(@stream.read(@options[:block_size]))
+      i += @options[:block_size]
+    end
+    
+    true
+  end
+  
+  def _extract(header, offset, dest, options)
+    if !options[:override] && File::exists?(dest)
+      return
+    end
+
+    case header[:type]
+    when :normal
+      export_to_file(offset, header[:size], header[:path], dest)
+    when :directory
+      if !File.exists? dest
+        Dir.mkdir(dest)
+      end
+    when :symbolic
+      File.symlink(header[:dest], dest)
+    when :link
+      if header[:dest][0] == "/"
+        FileUtils.touch(header[:dest])
+      else
+        FileUtils.touch(realpath("#{dest}/../#{header[:dest]}"))
+      end
+
+      File.link(header[:dest], dest)
+    when :block
+      system("mknod '#{dest}' b #{header[:major]} #{header[:minor]}")
+    when :character
+      system("mknod '#{dest}' c #{header[:major]} #{header[:minor]}")
+    when :fifo
+      system("mknod '#{dest}' p #{header[:major]} #{header[:minor]}")
+    end
+
+    if options[:preserve]
+      File.chmod(header[:mode], dest)
+      File.chown(header[:uid], header[:gid], dest)
+    end
+  end
+  
+  private
+  def _detect_compression(filename)
+    return :none unless filename.include? "."
+
+    case filename.slice(Range.new(filename.rindex(".") + 1, -1))
+    when "gz", "tgz"
+      return :gzip
+    when "bz2", "tbz", "tb2"
+      return :bzip2
+    when "xz", "txz"
+      return :xz
+    when "lz", "lzma", "tlz"
+      return :lzma
+    end
+
+    return :none
+  end
+  
+  def _generate_compressed_stream(stream, compression)
+    if compression == :auto
+      if stream.is_a? File
+        compression = _detect_compression(stream.path)
+      else
+        compression = :none
+      end
+    end
+    
+    programs = {
+      gzip: "gzip -d -c -f",
+      bzip2: "bzip2 -d -c -f",
+      lzma: "lzma -d -c -f",
+      xz: "xz -d -c -f"
+    }
+    
+    unless programs.key? compression
+      return stream
+    end
+    
+    io = IO::popen("/usr/bin/env #{programs[compression]}", "a+b")
+    new_file = File.open("#{@options[:tmpdir]}/#{rand(500512)}", "w+b")
+    Thread.new do
+      until stream.eof?
+        io.write(stream.read(@options[:block_size]))
+      end
+      
+      io.close_write
+    end
+    
+    until io.eof?
+      new_file.write(io.read(@options[:block_size]))
+    end
+    
+    new_file
+  end
+end

data/lib/archive/tar/stat.rb

@@ -0,0 +1,130 @@
+=begin license
+Copyright (c) 2010 Fritz Grimpen
+
+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.
+=end
+
+class Archive::Tar::Stat
+  attr_accessor :checksum, :path, :mode, :uid, :gid, :size, :mtime, :type,
+    :dest, :format, :user, :group, :atime, :ctime, :major, :minor
+  attr_accessor :path
+  attr_accessor :mode
+
+  def initialize
+    @path = ""
+    @mode = 0777
+    @uid = 0
+    @gid = 0
+    @size = 0
+    @mtime = Time.at(0)
+    @type = :normal
+    @dest = ""
+    @format = :ustar
+    @user = ""
+    @group = ""
+    @atime = Time.at(0)
+    @ctime = Time.at(0)
+    @major = 0
+    @minor = 0
+    @checksum = 0
+  end
+
+  def self.from_file(file)
+    file = File.new(file.to_s) unless file.is_a? File
+    stat = Archive::Tar::Stat.new
+    
+    file_stat = file.stat
+    path = file.path
+    
+    stat.path = path
+    stat.mode = file_stat.mode
+    stat.uid = file_stat.uid
+    stat.gid = file_stat.gid
+    stat.size = file_stat.size
+    stat.mtime = file_stat.mtime
+    
+    if file_stat.blockdev?
+      stat.type = :block
+      stat.size = 0
+    elsif file_stat.chardev?
+      stat.type = :character
+      stat.size = 0
+    elsif file_stat.directory?
+      stat.type = :directory
+      stat.size = 0
+    elsif file_stat.pipe?
+      stat.type = :fifo
+      stat.size = 0
+    elsif file_stat.symlink?
+      stat.type = :symbolic
+      stat.size = 0
+    else
+      stat.type = :normal
+    end
+    
+    stat.dest = File.readlink(path) if stat.type == :symbolic
+    stat.format = :ustar
+    stat.atime = file_stat.atime
+    stat.ctime = file_stat.ctime
+    
+    stat.major = file_stat.rdev_major
+    stat.minor = file_stat.rdev_minor
+    
+    stat
+  end
+  
+  def blocks
+    size % 512 == 0 ? size / 512 : (size + 512 - size % 512) / 512
+  end
+  
+  def is_ustar?
+    format == :ustar
+  end
+  
+  def ustar?
+    is_ustar?
+  end
+  
+  def is_gnu?
+    format == :gnu
+  end
+  
+  def gnu?
+    is_gnu?
+  end
+  
+  def version
+    "00"
+  end
+  
+  def [](name)
+    self.method(name.to_sym).call
+  end
+  
+  def []=(name, value)
+    self.method((name.to_s + "=").to_sym).call(value)
+  end
+  
+  def each(&block)
+    [ :path, :mode, :uid, :gid, :size, :mtime, :type, :dest, :format, :user,
+      :group, :major, :minor, :atime, :ctime, :checksum ].each do |elem|
+      block.call(elem, self[elem])
+    end
+  end
+end

data/lib/archive/tar/stream_reader.rb

@@ -0,0 +1,54 @@
+=begin license
+Copyright (c) 2010 Fritz Grimpen
+
+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.
+=end
+
+require "archive/tar/reader"
+
+class Archive::Tar::StreamReader < Archive::Tar::Reader
+  def initialize(stream, options = {})
+    options = {
+      block_size: 2 ** 19,
+      reload_time: 32
+    }.merge(options)
+    
+    stream = IO.new(stream) if io.is_a? Integer
+  
+    if options[:compression] == :auto
+      raise "Automatic compression is not available for streams"
+    end
+    
+    tmp_file = File.new("/tmp/" + rand(500000).to_s(16) + ".tar", "w+b")
+    Thread.new do
+      i = 0
+    
+      until stream.eof?
+        read = stream.read(options[:block_size])
+        tmp_file.write(read)
+        self.build_index if i % options[:reload_time] == 0
+        i += 1
+      end
+      
+      self.build_index
+    end
+    
+    super(tmp_file, options)
+  end
+end

data/lib/archive/tar/writer.rb

@@ -0,0 +1,117 @@
+=begin license
+Copyright (c) 2010 Fritz Grimpen
+
+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.
+=end
+
+require "archive/tar/stat.rb"
+require "archive/tar/format.rb"
+
+class Archive::Tar::WriterError < RuntimeError
+end
+
+class Archive::Tar::Writer
+  include Archive::Tar
+  
+  def initialize(stream, options = {})
+    options = {
+      block_size: 2 ** 19,
+      format: :gnu
+    }.merge(options)
+    
+    @options = options
+    @stream = stream
+    @inodes = {}
+  end
+  
+  def add_entry(header, content)
+    @atream.write(Archive::Tar::Format::pack_header(header))
+    
+    content = content[0, header.size].ljust(header.blocks * 512, "\0")
+    @stream.write(content)
+  end
+  
+  def add_file(file, path = nil)
+    file = File.is_a?(File) ? file : File.new(file)
+    path = path == nil ? file.path : path
+    
+    ino = File::Stat.new(file).ino
+    stat = Archive::Tar::Stat::from_file(file)
+    stat.path = path
+    stat.format = @options[:format]
+    if @inodes.has_key? ino && path != @inodes[ino]
+      stat.type = :link
+      stat.size = 0
+      stat.dest = @inodes[ino]
+    else
+      @inodes[ino] = path
+    end
+    
+    header = Archive::Tar::Format::pack_header(stat)
+    @stream.write(header)
+    
+    if stat.type == :normal
+      num_of_nils = stat.blocks * 512 - stat.size
+      until file.eof?
+        @stream.write(file.read(@options[:block_size]))
+      end
+      
+      @stream.write("\0" * num_of_nils)
+    end
+  end
+  
+  def add_directory(dir, options = {})
+    options = {
+      full_path: false,
+      recursive: true,
+      archive_base: ""
+    }.merge(options)
+    
+    real_base = dir
+    archive_base = options[:archive_base]
+    
+    unless dir.is_a? Dir
+      dir = Dir.open(dir)
+    end
+    
+    #add_file(dir.path, archive_base)
+    
+    dir.each do |entry|
+      if entry == "." || entry == ".."
+        next
+      end
+      
+      realpath = File.join(real_base, entry)
+      real_archive_path = join_path(archive_base, entry)
+      
+      add_file(realpath, real_archive_path)
+      
+      if File::Stat.new(realpath).directory? && options[:recursive]
+        new_options = options
+        new_options[:archive_base] = real_archive_path
+        
+        add_directory(realpath, new_options)
+      end
+    end
+  end
+  
+  def close()
+    @stream.write("\0" * 1024)
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: archive-tar2
+version: !ruby/object:Gem::Version
+  version: '1.5'
+  prerelease: 
+platform: ruby
+authors:
+- Fritz Grimpen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-02 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: fritz+archive-tar@grimpen.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/archive/tar/format.rb
+- lib/archive/tar/reader.rb
+- lib/archive/tar/stream_reader.rb
+- lib/archive/tar/writer.rb
+- lib/archive/tar/stat.rb
+- lib/archive/tar.rb
+homepage: http://grimpen.net/archive-tar
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Improved TAR implementation in Ruby
+test_files: []