archiverb 0.9.0

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Caleb Crane
+
+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,102 @@
+Archiverb provides Ruby bindings for creating
+[tar](http://en.wikipedia.org/wiki/Tar_(computing) and
+[ar](http://en.wikipedia.org/wiki/Ar_(Unix) archives in memory.
+
+## Install
+
+``gem install archiverb``
+
+## Use
+
+```ruby
+require "archiverb/ar"
+require "archiverb/tar"
+```
+
+## Adding files from the file system
+
+```ruby
+archive  = Archiverb::Ar.new(File.expand_path("../henryIV.ar", __FILE__))
+archive.add(File.expand_path("../spec/data/heneryIV.txt", __FILE__))
+archive.add(File.expand_path("../spec/data/heneryIV-westmoreland.txt", __FILE__))
+
+# archive will be written to henryIV.ar
+archive.write 
+```
+
+## Read an archive from the file system
+
+```ruby
+archive  = Archiverb::Ar.new(File.expand_path("../henryIV.ar", __FILE__))
+archive.read 
+
+archive.names # => ["heneryIV.txt", "heneryIV-westmoreland.txt"] 
+archive.files # => [#<Archiverb::File:0x007f8d7b90acf8 @name="heneryIV.txt" ... >, ...]
+```
+
+## Adding files from memory 
+
+```ruby
+archive  = Archiverb::Ar.new(File.expand_path("../henryIV.ar", __FILE__))
+
+contents = IO.read((File.expand_path("../spec/data/heneryIV.txt", __FILE__)))
+archive.add("henryIV.txt", contents)
+
+contents = IO.read((File.expand_path("../spec/data/heneryIV-westmoreland.txt", __FILE__)))
+archive.add("henryIV-westmoreland.txt", contents)
+
+archive.write 
+```
+
+
+```ruby
+archive  = Archiverb::Tar.new(File.expand_path("../henryIV.tar", __FILE__))
+
+archive.add("data/", :mode => 0744)
+
+contents = IO.read((File.expand_path("../spec/data/heneryIV.txt", __FILE__)))
+archive.add("data/henryIV.txt", contents)
+
+contents = IO.read((File.expand_path("../spec/data/heneryIV-westmoreland.txt", __FILE__)))
+archive.add("data/henryIV-westmoreland.txt", contents)
+
+archive.write 
+```
+
+## Working with Gzip Files
+
+### Writing to a Gzip file
+
+To create a gzipped tar archive, populate a ``Archiverb::Tar`` object in
+memory then create a ``GzipWriter`` object and pass it to
+``Archiverb::Tar#write``.
+
+```ruby
+require "zlib"
+
+path    = File.expand_path("../henryIV.tar", __FILE__)
+
+archive = Archiverb::Tar.new
+archive.add("data/henryIV.txt", 
+            IO.read((File.expand_path("../spec/data/heneryIV.txt", __FILE__))))
+archive.add("data/henryIV-westmoreland.txt", 
+            IO.read((File.expand_path("../spec/data/heneryIV-westmoreland.txt", __FILE__))))
+
+Zlib::GzipWriter.open(path) do |gz|
+  archive.write(gz)
+end
+```
+
+
+### Reading from a Gzip file
+
+```ruby
+require "zlib"
+
+File.open(File.expand_path("../henryIV.tgz", __FILE__)) do |f|
+  gz      = Zlib::GzipReader.new(f)
+  archive = Archiverb::Tar.new(gz)
+  archive.read
+  archive.names # => ["data/henryIV.txt", "data/henryIV-westmoreland.txt"] 
+end
+```

data/lib/archiverb.rb

@@ -0,0 +1,156 @@
+require "archiverb/stat"
+require "archiverb/file"
+
+# Provides a common interface for working with different types of
+# archive formats.
+#
+# @example
+#   arc = Archiverb::Ar.new("junk.ar", "a.txt", "b.txt", "c.txt")
+#   arc.write("/tmp/junk.ar")  # => creates /tmp/junk.ar with {a,b,c}.txt
+class Archiverb
+  module Error; end
+  class StandarError < ::StandardError; include Error; end
+  class ArgumentError < ::ArgumentError; include Error; end
+  class InvalidFormat < StandardError; end
+  class WrongChksum < StandardError; end
+  class AbstractMethod < StandardError; end
+
+  include Enumerable
+
+  def initialize(path_or_io = nil, *files, &blk)
+    raise NotImplementedError if self.class == Archiverb
+    @opts = files.last.is_a?(Hash) ? files.pop : {}
+    files.each { |file|  add(file) }
+    if block_given?
+      r, w = IO.pipe
+      @source = lambda do
+        blk.call(w)
+        w.close unless w.closed?
+        r
+      end
+    else
+      @source = lambda { path_or_io.is_a?(String) ? ::File.new(path_or_io, "a+").tap{|f| f.rewind } : path_or_io }
+    end
+    @out = path_or_io
+    @files = {}
+  end
+
+  def path
+    @out
+  end
+
+  def files
+    @files.values
+  end
+
+  def [](file)
+    @files[file]
+  end
+
+  # Iterate over each file.
+  # @yield { |name, file| }
+  def each(&blk)
+    @files.each(&blk)
+  end
+
+  def names
+    @files.keys
+  end
+
+  def count
+    @files.keys.length
+  end
+
+  # Pulls each file out of the archive and places them in #files.
+  # @todo take a block and yield each file as it's read without storing it in #files
+  def read
+    return self if @source.nil?
+    io = @source.call
+    io.respond_to?(:binmode) && io.binmode
+    preprocess(io)
+    while (header = next_header(io))
+      @files[header[:name]] = File.new(header[:name], read_file(header, io), Stat.new(header))
+    end
+    io.close
+    self
+  end
+
+  # Add a file to the archive.
+  # @param [String, File, IO]
+  # @param [Hash] opts options to pass to Stat.new
+  # @param [IO, ::File, String, StringIO] io
+  def add(name, opts = {}, io = nil, &blk)
+    if block_given?
+      @files[name] = File.new(name, *IO.pipe, &blk)
+      return self
+    end
+
+    if io
+      opts, io = io, opts if io.is_a?(Hash)
+    elsif !opts.is_a?(Hash)
+      opts, io = {}, opts
+    end
+
+    if io
+      if io.is_a?(String) || io.is_a?(StringIO) || io.is_a?(IO) || io.is_a?(::File)
+        @files[name] = File.new(name, io, Stat.new(io, opts))
+      else
+        raise ArgumentError.new("unsupported data source: #{io.class}")
+      end
+    else
+      case name
+      when String
+        fio = ::File.exists?(name) ? ::File.new(name, "r") : ""
+        @files[name] = File.new(name, fio, Stat.new(fio, opts))
+      when ::File
+        @files[name.path] = File.new(name.path, name, Stat.new(name, opts))
+      else
+        opts[:name] = name.respond_to?(:path) ? name.path : name.__id__.to_s if opts[:name].nil?
+        @files[opts[:name]] = File.new(opts[:name], name, Stat.new(name, opts))
+      end
+    end
+
+    self
+  end
+
+  def write(path = @out, &blk)
+    if block_given?
+      # use a pipe instead?
+      yield StringIO.new.tap { |io| write_to(io) }.string
+    elsif path.is_a?(String)
+      ::File.open(path, "w") { |io| write_to(io) }
+    else
+      path.respond_to?(:truncate) && path.truncate
+      write_to(path)
+    end
+    self
+  end
+
+private
+
+
+  # Abstract method
+  # Write all files in the archive, in the archive format, to the given IO
+  # @return [Hash] must have :name, :mtime, :uid, :gid, and mode
+  def write_io(io)
+    raise AbstractMethod
+  end
+
+  # Abstract method
+  # Get the next header for the next file
+  def next_header(io)
+    raise AbstractMethod
+  end
+
+  # Abstract method
+  # Perform any preprocessing and validation on the archive.
+  # Inheriting classes aren't requried to implement this method.
+  def preprocess(io)
+  end
+
+  # Abstract method
+  # Given a file header and an IO that is the archive retrieve the file.
+  def read_file(header, io)
+    raise AbstractMethod
+  end
+end # class::Archiverb

data/lib/archiverb/ar.rb

@@ -0,0 +1,60 @@
+require 'archiverb'
+
+class Archiverb
+  class Ar < Archiverb
+
+  private
+
+    def write_to(io)
+      io.write("!<arch>\n")
+      @files.each do |_, file|
+        normal         = [:name, :mtime, :uid, :gid, :mode].inject({}){|n,k| n.tap{ n[k] = file.send(k) } }
+        normal[:mtime] = normal[:mtime].to_i
+        normal[:raw]   = file.read
+        if normal[:name].length > 16
+          normal[:name]   = "#1/#{file.name.length + 3}"
+          normal[:raw]    = "#{file.name}\0\0\0" + normal[:raw]
+          normal[:size]  = file.name.length + 3
+        end
+        normal[:size]  = normal[:raw].length
+        printf(io, "%-16s%-12u%-6d%-6d%-8o%-10u`\n", *[:name, :mtime, :uid, :gid, :mode, :size].map{|k| normal[k]})
+        io.write(normal[:raw])
+        io.write("\n") if io.pos % 2 == 1
+      end
+      io.close
+      self
+    end
+
+    def next_header(io)
+      return nil if io.eof?
+      io.read(1) if io.pos % 2 == 1
+      header = {}
+      header[:name]  = io.read(16) || (return nil)
+      header[:name].strip!
+      header[:mtime]  = io.read(12) || (return nil)
+      header[:uid] = io.read(6).to_i
+      header[:gid] = io.read(6).to_i
+      header[:mode]  = io.read(8).to_i(8)
+      header[:size] = io.read(10).to_i
+      header[:magic] = io.read(2)
+      raise InvalidFormat unless header[:magic] == "`\n"
+      if header[:name][0..2] == "#1/"
+        # bsd format extended file name
+        header[:name] = io.read(header[:name][3..-1].to_i)
+        header[:size] -= header[:name].length
+        header[:name] = header[:name][0..-4]
+        # @todo support gnu format for extended file name
+      end
+      header
+    end # next_header(io)
+
+    def preprocess(io)
+      raise InvalidFormat unless io.read(8) == "!<arch>\n"
+    end
+
+    def read_file(header, io)
+      io.read(header[:size])
+    end
+
+  end # class::Ar
+end # class::Archiverb

data/lib/archiverb/file.rb

@@ -0,0 +1,76 @@
+require "stringio"
+
+class Archiverb
+  class File
+    # the basename of the file
+    attr_reader :name
+    # the directory path leading to the file
+    attr_reader :dir
+    # the path and name of the file
+    attr_reader :path
+    # octal mode
+    attr_accessor :mode
+    # The user id and group id of the file. Set #stat.uname and #stat.gname
+    # to force ownership by name rather than id.
+    attr_reader :uid, :gid
+    # @return [Time] modification time
+    attr_reader :mtime
+
+    attr_reader :size
+    alias :bytes :size
+
+    # the raw io object, you can add to it prior to calling read
+    attr_reader :io
+    # [Archiverb::Stat]
+    attr_reader :stat
+
+    def initialize(name, io, buff=io, stat=nil, &blk)
+      buff,stat = stat, buff if buff.is_a?(Stat) || buff.is_a?(::File::Stat)
+      stat = Stat.new(io) if stat.nil?
+
+      @name  = ::File.basename(name)
+      @dir   = ::File.dirname(name)
+      @path  = name
+      @mtime = stat.mtime.is_a?(Fixnum) ? Time.at(stat.mtime) : stat.mtime
+      @uid   = stat.uid
+      @gid   = stat.gid
+      @mode  = stat.mode
+      @size = stat.size
+
+      @readbuff = buff
+      @readback = blk unless blk.nil?
+      @io       = io.is_a?(String) ? StringIO.new(io) : io
+      @io.binmode
+      if @io.respond_to?(:path) && ::File.directory?(@io.path)
+        @size     = 0
+      end
+      @stat     = stat
+    end # initialize(io, stat)
+
+    def read
+      return @raw if @raw
+
+      if @readback && @readbuff
+        @readback.call(@readbuff)
+        @readbuff.close_write
+      end
+
+      @io.rewind unless @stat.pipe?
+
+      if @io.respond_to?(:path) && ::File.directory?(@io.path)
+        @raw  = ""
+      else
+        @raw    = @io.read
+        @size  = @raw.length
+      end
+      @io.close
+      @raw
+    end # read
+
+    # Prevents future access to the contents of the file and hopefully frees up memory.
+    def close
+      @raw = nil
+    end # close
+
+  end # class::File
+end # class::Archiverb

data/lib/archiverb/stat.rb

@@ -0,0 +1,55 @@
+require "ostruct"
+class Archiverb
+  class Stat < OpenStruct
+    @@reqdatrs = [ :dev    , :dev_major , :dev_minor  , :ino        , :mode  , :nlink   ,
+                   :gid    , :uid       , :rdev_major , :rdev_minor , :size  , :blksize ,
+                   :blocks , :atime     , :mtime      , :ctime      , :ftype , :pipe?   ,
+                   :rdev   , :symlink?
+                 ]
+    def initialize(io, start = {})
+      return super(Hash[@@reqdatrs.map{|m| [m, def_v(m)]}].merge(io)) if io.is_a?(Hash)
+      return super(stat_hash(io).merge(start)) if io.is_a?(::File::Stat)
+
+      statm = [:lstat, :stat].find{|m| io.respond_to?(m)}
+      return super(Hash[@@reqdatrs.map{|m| [m, def_v(m)]}].merge(stat_hash(io)).merge(start)) if statm.nil?
+
+      hash = stat_hash(io.send(statm))
+      hash[:readlink] = ::File.readlink(io) if hash[:symlink?]
+      return super(hash.merge(start))
+    end
+
+    # ASCII representation of the owner and group of the file respectively.
+    # In TAR, if found, the user and group IDs are used rather than the values
+    # in the uid and gid fields.
+    attr_accessor :uname, :gname
+
+
+  private
+
+    def def_v(attr)
+      case attr
+      when :atime, :ctime, :mtime
+        Time.new
+      when :size
+        0
+      when :gid
+        Process.egid
+      when :uid
+        Process.euid
+      when :mode
+        0644
+      when :ftype
+        "file"
+      else
+        false
+      end
+    end
+
+    def stat_hash(stat)
+      @@reqdatrs.inject({})  do |h , meth|
+          h[meth] = stat.respond_to?(meth) ? stat.send(meth) : def_v(meth)
+          h
+      end
+    end # stat_hash(stat, syms
+  end # class::Stat < Openstruct
+end # class::Archiverb

data/lib/archiverb/tar.rb

@@ -0,0 +1,214 @@
+require 'archiverb'
+require 'etc'
+
+class Archiverb
+  # GNU tar implementation
+  # @see http://en.wikipedia.org/wiki/Tar_(file_format)
+  # @see http://www.gnu.org/software/tar/manual/html_node/Standard.html
+  # @see http://www.subspacefield.org/~vax/tar_format.html
+  class Tar < Archiverb
+    TMAGIC       = 'ustar'
+    TVERSION     = "00"
+    OLDGNU_MAGIC = "ustar  \0"
+    REGTYPE      = '0'  # regular file
+    AREGTYPE     = "\0" # regular file
+    LNKTYPE      = '1'  # link
+    SYMTYPE      = '2'  # reserved (symlink)
+    CHRTYPE      = '3'  # character special
+    BLKTYPE      = '4'  # block special
+    DIRTYPE      = '5'  # directory
+    FIFOTYPE     = '6'  # FIFO special
+    CONTTYPE     = '7'  # reserved (contiguous file)
+    XHDTYPE      = 'x'  # extended header referring to next file in archive
+    XGLTYPE      = 'g'  # global extended header
+
+
+  private
+
+    def write_to(io)
+      @files.each do |name, file|
+        if name.length > 100
+          name, prefix = name[0..99], name[100..-1]
+          if prefix > 155
+            raise ArgumentError.new("file name cannot exceed 255 characters: #{name}#{prefix}")
+          end
+        else
+          prefix = ""
+        end
+        header = "#{name}" + ("\0" * (100 - name.length))
+        # @todo double check the modes on links
+        # input header: data/henryIV.txt0000755000076500000240000000000011706250470015332 2heneryIV.txtustar  calebstaff
+        # output header: data/henryIV.txt0050423000076500000240000000001411706305252015333 2heneryIV.txtustar  calebstaff
+
+        # offset 100
+        header += sprintf("%.7o\0", file.mode)
+        # offset 108
+        header += sprintf("%.7o\0", file.uid)
+        # offset 116
+        header += sprintf("%.7o\0", file.gid)
+        # offset 124
+        header += sprintf("%.11o\0", file.size)
+        # offset 136
+        header += sprintf("%.11o\0", file.mtime.to_i)
+        # offset 148
+        header += " " * 8 # write 8 blanks for the checksum, we'll replace it later
+
+        # offset 156
+        if [LNKTYPE, SYMTYPE].include?(type = tar_type(file.stat))
+          header += sprintf("%.1o", type)
+          raise ArgumentError.new("#{name} link type files' stat objects must contain a readlink") if file.stat.readlink.nil?
+          # offset 157
+          header += "#{file.stat.readlink}\0" + ("\0" * (99 - file.stat.readlink.length))
+        else
+          type = DIRTYPE if name[-1] == "/"
+          header += sprintf("%.1o", type)
+          # offset 157
+          header += "\0"*100
+        end
+
+        # offset 257
+        header += OLDGNU_MAGIC
+
+        uname = file.stat.uname || Etc.getpwuid(file.uid).name
+        gname = file.stat.gname || Etc.getgrgid(file.gid).name
+        # offset 265
+        header += "#{uname}\0" + ("\0" * (31 - uname.length))
+        # offset 297
+        header += "#{gname}\0" + ("\0" * (31 - gname.length))
+
+        # offset 329
+        if type == CHRTYPE || type ==BLKTYPE
+          header += sprintf("%.7o\0", file.stat.dev_major)
+          header += sprintf("%.7o\0", file.stat.dev_minor)
+        else
+          header += "\0" * 16
+        end
+
+        # offset 345
+        header += "#{prefix}" + ("\0" * (155 - (prefix || "").length))
+
+        # offset 500
+        header += "\0" * 12
+
+        header = header[0..147] + chksum(header) + header[156..-1]
+        io.write(header)
+        io.write(file.read).tap do |len|
+          unless (overflow = len % 512) == 0
+            io.write("\0" * (512 - (overflow)))
+          end
+        end
+      end # name, file
+
+      io.write("\0" * 1024)
+      self
+    end # write_to(io)
+
+    def next_header(io)
+      return nil if io.eof?
+      if (raw = io.read(512)).strip == ""
+        return nil if(raw = io.read(512)).strip == ""
+      end # raw.strip == ""
+
+      header            = {}
+      header[:name]     = raw[0..99].strip
+      check             = chksum(raw)
+      header[:chksum]   = raw[148..155]
+      raise WrongChksum.new("#{header[:name]}: #{header[:chksum]} expected to be #{check}") unless header[:chksum] == check
+      header[:mode]     = raw[100..107].to_i(8)
+      header[:uid]      = Integer(raw[108..115].strip)
+      header[:gid]      = Integer(raw[116..123].strip)
+      header[:size]     = Integer(raw[124..135].strip)
+      header[:mtime]    = raw[136..147].strip
+      header[:mtime]    = "0#{header[:mtime]}" if header[:mtime].length == 11
+      header[:mtime]    = Time.at(Integer(header[:mtime]))
+      # @todo check for XHDTYPE, or XGLTYPE
+      header[:ftype]     = stat_type(raw[156])
+      header[:readlink]  = raw[157..256].strip
+      header[:magic]     = raw[257..262].strip
+      header[:version]   = raw[263..264].strip
+      header[:uname]     = raw[265..296].strip
+      header[:gname]     = raw[297..328].strip
+      header[:dev_major] = raw[329..336].strip
+      header[:dev_minor] = raw[337..344].strip
+      header[:prefix]    = raw[345..500].strip
+      header.merge!(pull_ustar(raw)) if header[:magic] == TMAGIC
+      header
+    end
+
+    def tar_type(stat)
+      case stat.ftype
+      when 'file'
+        REGTYPE
+      when 'directory'
+        DIRTYPE
+      when 'characterSpecial'
+        CHRTYPE
+      when 'blockSpecial'
+        BLKTYPE
+      when 'fifo'
+        FIFOTYPE
+      when 'link'
+        #LNKTYPE
+        SYMTYPE
+      else
+        warn "file type: #{stat.ftype} is not supported; treating it as a regular file"
+        REGTYPE
+      end
+    end # tar_type(stat)
+
+    def stat_type(bit)
+      case bit
+      when REGTYPE, AREGTYPE
+        'file'
+      when LNKTYPE, SYMTYPE
+        'link'
+      when CHRTYPE
+        'characterSpecial'
+      when BLKTYPE
+        'blockSpecial'
+      when DIRTYPE
+        'directory'
+      when FIFOTYPE
+        'fifo'
+      when CONTTYPE, XHDTYPE, XGLTYPE
+        'unknown'
+      else
+        warn "file type #{bit} is not supported; treating it as a regular file"
+        'regular'
+      end
+    end # stat_type(bit)
+    def read_file(header, io)
+      io.read(header[:size]).tap do |raw|
+        if (diff = header[:size] % 512) != 0
+          io.read(512 - diff)
+        end
+      end # raw
+    end
+
+    def pull_ustar(raw)
+      header              = {}
+      header[:prefix]     = raw[345].strip
+      header[:fill2]      = raw[346].strip
+      header[:fill3]      = raw[347..354].strip
+      header[:isextended] = raw[355]
+      header[:sparse]     = raw[356..451].strip
+      header[:realsize]   = raw[452..463].strip
+      header[:offset]     = raw[464..475].strip
+      header[:atime]      = raw[476..487].strip
+      header[:ctime]      = raw[488..499].strip
+      header[:mfill]      = raw[500..507].strip
+      header[:xmagic]     = raw[508..511].strip
+      header
+    end # pull_ustar(header)
+
+    # The checksum is calculated by taking the sum of the unsigned byte
+    # values of the header block with the eight checksum bytes taken to
+    # be ascii spaces (decimal value 32). It is stored as a six digit
+    # octal number with leading zeroes followed by a NUL and then a
+    # space.
+    def chksum(header)
+      sprintf("%.6o\0 ", (header[0..147] + header[156..500]).each_byte.inject(256) { |s,b| s+b })
+    end
+
+  end # class::Tar < Archiverb
+end # class::Archiverb

data/lib/archiverb/version.rb

@@ -0,0 +1,3 @@
+class Archiverb
+  VERSION = '0.9.0'
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: archiverb
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- Caleb Crane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- archiverb@simulacre.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/archiverb/ar.rb
+- lib/archiverb/file.rb
+- lib/archiverb/stat.rb
+- lib/archiverb/tar.rb
+- lib/archiverb/version.rb
+- lib/archiverb.rb
+- README.md
+- LICENSE.txt
+homepage: http://github.com/simulacre/archiverb
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Native Ruby implementations of tar and ar archives
+test_files: []
+has_rdoc: