libarchive-ruby-swig 0.2.0

data/ext/libarchive-ruby-swig/entry.cpp

@@ -0,0 +1,277 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+#include <cstring>
+#include <string>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <archive.h>
+#include <archive_entry.h>
+#include <ruby.h>
+#include "entry.h"
+#include "error.h"
+
+Entry::Entry(struct archive_entry *entry)
+{
+    _entry = entry;
+}
+
+Entry::~Entry()
+{
+    if(_entry) {
+        archive_entry_free(_entry);
+        _entry = 0;
+    }
+}
+
+bool Entry::is_file()
+{
+    return S_ISREG(archive_entry_filetype(_entry));
+}
+
+bool Entry::is_directory()
+{
+    return S_ISDIR(archive_entry_filetype(_entry));
+}
+
+bool Entry::is_symbolic_link()
+{
+    return S_ISLNK(archive_entry_filetype(_entry));
+}
+
+bool Entry::is_block_special()
+{
+    return S_ISBLK(archive_entry_filetype(_entry));
+}
+
+bool Entry::is_character_special()
+{
+    return S_ISCHR(archive_entry_filetype(_entry));
+}
+
+bool Entry::is_fifo()
+{
+    return S_ISFIFO(archive_entry_filetype(_entry));
+}
+
+bool Entry::is_socket()
+{
+    return S_ISSOCK(archive_entry_filetype(_entry));
+}
+
+void Entry::set_filetype(unsigned int filetype)
+{
+    archive_entry_set_filetype(_entry, filetype);
+}
+
+unsigned int Entry::devmajor()
+{
+    return archive_entry_devmajor(_entry);
+}
+
+void Entry::set_devmajor(unsigned int devmajor)
+{
+    archive_entry_set_devmajor(_entry, devmajor);
+}
+
+unsigned int Entry::devminor()
+{
+    return archive_entry_devminor(_entry);
+}
+
+void Entry::set_devminor(unsigned int devminor)
+{
+    archive_entry_set_devminor(_entry, devminor);
+}
+
+unsigned long Entry::atime()
+{
+    archive_entry_atime(_entry);
+}
+
+void Entry::set_atime(unsigned long atime)
+{
+    archive_entry_set_atime(_entry, atime, 0);
+}
+
+void Entry::clear()
+{
+    archive_entry_clear(_entry);
+}
+
+Entry *Entry::clone()
+{
+    new Entry(archive_entry_clone(_entry));
+}
+
+unsigned long Entry::dev()
+{
+    return archive_entry_dev(_entry);
+}
+
+void Entry::set_dev(unsigned long dev)
+{
+    archive_entry_set_dev(_entry, dev);
+}
+
+unsigned long Entry::gid()
+{
+    return archive_entry_gid(_entry);
+}
+
+void Entry::set_gid(unsigned long gid)
+{
+    archive_entry_set_gid(_entry, gid);
+}
+
+const char *Entry::gname()
+{
+    return archive_entry_gname(_entry);
+}
+
+void Entry::set_gname(const char *gname)
+{
+    archive_entry_copy_gname(_entry, gname);
+}
+
+const char *Entry::hardlink()
+{
+    return archive_entry_hardlink(_entry);
+}
+
+void Entry::set_hardlink(const char *hardlink)
+{
+    archive_entry_copy_hardlink(_entry, hardlink);
+}
+
+unsigned long Entry::ino()
+{
+    return archive_entry_ino(_entry);
+}
+
+void Entry::set_ino(unsigned long ino)
+{
+    archive_entry_set_ino(_entry, ino);
+}
+
+int Entry::mode()
+{
+    return archive_entry_mode(_entry);
+}
+
+void Entry::set_mode(int mode)
+{
+    archive_entry_set_mode(_entry, mode);
+}
+
+unsigned long Entry::mtime()
+{
+    return archive_entry_mtime(_entry);
+}
+
+void Entry::set_mtime(unsigned long mtime)
+{
+    archive_entry_set_mtime(_entry, mtime, 0);
+}
+
+unsigned int Entry::nlink()
+{
+    return archive_entry_nlink(_entry);
+}
+
+void Entry::set_nlink(unsigned int nlink)
+{
+    archive_entry_set_nlink(_entry, nlink);
+}
+
+const char *Entry::pathname()
+{
+    return archive_entry_pathname(_entry);
+}
+
+void Entry::set_pathname(const char *pathname)
+{
+    archive_entry_copy_pathname(_entry, pathname);
+}
+
+unsigned int Entry::rdevmajor()
+{
+    return archive_entry_rdevmajor(_entry);
+}
+
+void Entry::set_rdevmajor(unsigned int rdevmajor)
+{
+    archive_entry_set_rdevmajor(_entry, rdevmajor);
+}
+
+unsigned int Entry::rdevminor()
+{
+    return archive_entry_rdevminor(_entry);
+}
+
+void Entry::set_rdevminor(unsigned int rdevminor)
+{
+    archive_entry_set_rdevminor(_entry, rdevminor);
+}
+
+unsigned long Entry::size()
+{
+    return archive_entry_size(_entry);
+}
+
+void Entry::set_size(unsigned long size)
+{
+    archive_entry_set_size(_entry, size);
+}
+
+const char *Entry::symlink()
+{
+    return archive_entry_symlink(_entry);
+}
+
+void Entry::set_symlink(const char *symlink)
+{
+    archive_entry_copy_symlink(_entry, symlink);
+}
+
+unsigned long Entry::uid()
+{
+    return archive_entry_uid(_entry);
+}
+
+void Entry::set_uid(unsigned long uid)
+{
+    archive_entry_set_uid(_entry, uid);
+}
+
+const char *Entry::uname()
+{
+    return archive_entry_uname(_entry);
+}
+
+void Entry::set_uname(const char *uname)
+{
+    archive_entry_copy_uname(_entry, uname);
+}
+
+void Entry::copy_stat_helper(const char *filename)
+{
+    struct stat sb;
+    if(lstat(filename, &sb) == -1) {
+        std::string error_msg = strerror(errno);
+        throw Error(error_msg);
+    }
+
+    archive_entry_copy_stat(_entry, &sb);
+}
+

data/ext/libarchive-ruby-swig/entry.h

@@ -0,0 +1,121 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+#ifndef CLASS_ARCHIVE_ENTRY_H_INCLUDED
+#define CLASS_ARCHIVE_ENTRY_H_INCLUDED
+
+#include "writer.h"
+
+struct archive_entry;
+
+class Entry
+{
+    friend void Writer::write_header(Entry *entry);
+
+    public:
+        Entry(struct archive_entry *entry);
+        virtual ~Entry();
+
+        bool is_file();
+        bool is_directory();
+        bool is_symbolic_link();
+        bool is_block_special();
+        bool is_character_special();
+        bool is_fifo();
+        bool is_socket();
+
+        void set_filetype(unsigned int filetype);
+
+        unsigned int devmajor();
+        void set_devmajor(unsigned int devmajor);
+
+        unsigned int devminor();
+        void set_devminor(unsigned int devminor);
+
+        unsigned long atime();
+        void set_atime(unsigned long atime);
+
+        void clear();
+
+#ifdef SWIG
+%newobject clone(Entry *entry);
+#endif
+
+        Entry *clone();
+
+        unsigned long dev();
+        void set_dev(unsigned long dev);
+
+        unsigned long gid();
+        void set_gid(unsigned long gid);
+
+        const char *gname();
+        void set_gname(const char *gname);
+
+        const char *hardlink();
+        void set_hardlink(const char *hardlink);
+
+        unsigned long ino();
+        void set_ino(unsigned long ino);
+
+        int mode();
+        void set_mode(int mode);
+
+        unsigned long mtime();
+        void set_mtime(unsigned long mtime);
+
+        unsigned int nlink();
+        void set_nlink(unsigned int nlink);
+
+        const char *pathname();
+        void set_pathname(const char *pathname);
+
+        unsigned int rdevmajor();
+        void set_rdevmajor(unsigned int rdevmajor);
+
+        unsigned int rdevminor();
+        void set_rdevminor(unsigned int rdevminor);
+
+        unsigned long size();
+        void set_size(unsigned long size);
+
+        const char *symlink();
+        void set_symlink(const char *symlink);
+
+        unsigned long uid();
+        void set_uid(unsigned long uid);
+
+        const char *uname();
+        void set_uname(const char *uname);
+
+#ifdef SWIG
+%exception {
+    try {
+        $action
+    } catch(Error &err) {
+        static VALUE c_archive = rb_define_module("Archive");
+        static VALUE e_archive =
+            rb_define_class_under(c_archive, "Error", rb_eStandardError);
+        rb_raise(e_archive, err.what());
+    }
+}
+#endif
+
+        void copy_stat_helper(const char *filename);
+
+#ifdef SWIG
+%exception;
+#endif
+
+    private:
+        struct archive_entry *_entry;
+};
+
+#endif

data/ext/libarchive-ruby-swig/error.h

@@ -0,0 +1,35 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+#ifndef CLASS_ARCHIVE_ERROR_H_INCLUDED
+#define CLASS_ARCHIVE_ERROR_H_INCLUDED
+
+#include <exception>
+
+class Error: public std::exception
+{
+    public:
+
+        Error(const std::string &error_msg)
+            : error_msg(error_msg) {};
+
+        virtual ~Error() throw()
+            {};
+
+        virtual const char *what() const throw() {
+            return error_msg.c_str();
+        }
+
+    private:
+
+        std::string error_msg;
+};
+
+#endif

data/ext/libarchive-ruby-swig/extconf.rb

@@ -0,0 +1,31 @@
+#
+# This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+# libarchive.
+#
+# Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+# 
+# libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+# license text can be found in the file LICENSE.txt distributed with the source.
+#
+
+require 'mkmf'
+
+unless have_header('archive.h') && \
+  have_library('archive', 'archive_read_open_filename')
+  $stderr.write "Libarchive development files not found.\n"
+  exit 1
+end
+
+if find_executable('g++')
+  $libs = append_library($libs, "stdc++")
+end
+
+if swig = find_executable('swig')
+  `#{swig} -c++ -ruby -features autodoc libarchive.i`
+  $distcleanfiles << 'libarchive_wrap.cxx'
+else
+  $stderr.write "You need SWIG to compile this extension.\n"
+  exit 1
+end
+
+create_makefile('archive') 

data/ext/libarchive-ruby-swig/libarchive.i

@@ -0,0 +1,30 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+%module archive
+
+%{
+#include <archive.h>
+#include <archive_entry.h>
+#include <ruby.h>
+#include "reader.h"
+#include "writer.h"
+#include "entry.h"
+#include "error.h"
+%}
+
+%wrapper %{
+/* --- WRAPPER CODE START --- */
+%}
+
+%include "reader.h"
+%include "writer.h"
+%include "entry.h"
+

data/ext/libarchive-ruby-swig/reader.cpp

@@ -0,0 +1,119 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+#include <string>
+#include <archive.h>
+#include <archive_entry.h>
+#include <ruby.h>
+#include "reader.h"
+#include "entry.h"
+#include "error.h"
+
+Reader::Reader(struct archive *ar)
+    : _ar(ar),
+    _buf((char*) malloc(1024)),
+    _buf_size(1024)
+{}
+
+
+Reader::~Reader()
+{
+    this->close();
+    free(_buf);
+    _buf = 0;
+    _buf_size = 0;
+}
+
+
+void Reader::close()
+{
+    if(_ar) {
+        archive_read_finish(_ar);
+        _ar = 0;
+    }
+}
+
+
+Reader *Reader::read_open_filename(const char * filename) 
+{
+    struct archive *ar = archive_read_new();
+
+    try {
+        if(archive_read_support_compression_all(ar) != ARCHIVE_OK)
+            throw 0;
+
+        if(archive_read_support_format_all(ar) != ARCHIVE_OK)
+            throw 0;
+
+        if(archive_read_open_filename(ar, filename, 1024) != ARCHIVE_OK)
+            throw 0;
+
+    } catch(...) {
+        std::string error_msg = archive_error_string(ar);
+        archive_read_finish(ar);
+        throw Error(error_msg);
+    }
+
+    return new Reader(ar);
+}
+
+
+Entry *Reader::next_header()
+{
+    Entry * result = 0;
+    std::string error_msg = "operation on uninitialized archive";
+
+    if(!_ar)
+        throw Error(error_msg);
+
+    struct archive_entry *entry = archive_entry_new();
+    int rval = archive_read_next_header2(_ar, entry);
+
+    switch(rval) {
+        case ARCHIVE_EOF:
+            archive_entry_free(entry);
+            close();
+            break;
+        case ARCHIVE_OK:
+            result = new Entry(entry);
+            break;
+        default:
+            archive_entry_free(entry);
+            error_msg = archive_error_string(_ar);
+            throw Error(error_msg);
+    }
+
+    return result;
+}
+
+
+VALUE Reader::read_data_helper(int len)
+{
+    std::string error_msg = "error while reading from archive";
+
+    if(len > _buf_size) {
+        _buf = (char*) realloc(_buf, len);
+        _buf_size = len;
+    }
+
+    ssize_t rval = archive_read_data(_ar, (void*) _buf, len);
+
+    switch(rval) {
+        case ARCHIVE_FATAL:
+        case ARCHIVE_WARN:
+        case ARCHIVE_RETRY:
+            error_msg = archive_error_string(_ar);
+            throw Error(error_msg);
+        case 0:
+            return 0;
+    }
+
+    return rb_tainted_str_new(_buf, rval);
+}

data/ext/libarchive-ruby-swig/reader.h

@@ -0,0 +1,60 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+#ifndef CLASS_ARCHIVE_READER_H_INCLUDED
+#define CLASS_ARCHIVE_READER_H_INCLUDED
+
+struct archive;
+class Entry;
+
+#ifndef SWIG
+#include <ruby.h>
+#endif
+
+class Reader
+{
+    public:
+        Reader(struct archive *ar);
+        virtual ~Reader();
+        void close();
+
+#ifdef SWIG
+%exception {
+    try {
+        $action
+    } catch(Error &err) {
+        static VALUE c_archive = rb_define_module("Archive");
+        static VALUE e_archive =
+            rb_define_class_under(c_archive, "Error", rb_eStandardError);
+        rb_raise(e_archive, err.what());
+    }
+}
+#endif
+
+#ifdef SWIG
+%newobject read_open_filename(const char *filename);
+%newobject next_header();
+#endif
+
+        static Reader *read_open_filename(const char *filename);
+        Entry *next_header();
+        VALUE read_data_helper(int len);
+
+#ifdef SWIG
+%exception;
+#endif
+
+    private:
+        struct archive *_ar;
+        char *_buf;
+        int _buf_size;
+};
+
+#endif

data/ext/libarchive-ruby-swig/writer.cpp

@@ -0,0 +1,141 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+#include <string>
+#include <archive.h>
+#include <archive_entry.h>
+#include <ruby.h>
+#include "writer.h"
+#include "entry.h"
+#include "error.h"
+
+Writer::Writer(struct archive *ar)
+    :_ar(ar),
+    _buf(0),
+    _buf_size(0)
+{}
+
+
+Writer::~Writer()
+{
+    this->close();
+    free(_buf);
+    _buf = 0;
+    _buf_size = 0;
+}
+
+
+void Writer::close()
+{
+    if(_ar) {
+        archive_write_finish(_ar);
+        _ar = 0;
+    }
+}
+
+
+Writer *Writer::write_open_filename(const char *filename,
+    int compression, int format)
+{
+    std::string error_msg;
+    struct archive *ar = archive_write_new();
+
+    try {
+
+        switch(compression) {
+            case Archive::COMPRESSION_BZIP2:
+                archive_write_set_compression_bzip2(ar);
+                break;
+            case Archive::COMPRESSION_COMPRESS:
+                archive_write_set_compression_compress(ar);
+                break;
+            case Archive::COMPRESSION_GZIP:
+                archive_write_set_compression_gzip(ar);
+                break;
+            case Archive::COMPRESSION_LZMA:
+                archive_write_set_compression_lzma(ar);
+                break;
+            case Archive::COMPRESSION_NONE:
+                archive_write_set_compression_none(ar);
+                break;
+            case Archive::COMPRESSION_XZ:
+                archive_write_set_compression_xz(ar);
+                break;
+            default:
+                error_msg = "unknown or unsupported compression scheme";
+                throw Error(error_msg);
+        }
+
+        switch(format) {
+            case Archive::FORMAT_AR_BSD:
+                archive_write_set_format_ar_bsd(ar);
+                break;
+            case Archive::FORMAT_AR_SVR4:
+                archive_write_set_format_ar_svr4(ar);
+                break;
+            case Archive::FORMAT_CPIO:
+                archive_write_set_format_cpio(ar);
+                break;
+            case Archive::FORMAT_CPIO_NEWC:
+                archive_write_set_format_cpio_newc(ar);
+                break;
+            case Archive::FORMAT_MTREE:
+                archive_write_set_format_mtree(ar);
+                break;
+            case Archive::FORMAT_TAR:
+            case Archive::FORMAT_TAR_PAX_RESTRICTED:
+                archive_write_set_format_pax_restricted(ar);
+                break;
+            case Archive::FORMAT_TAR_PAX_INTERCHANGE:
+                archive_write_set_format_pax(ar);
+                break;
+            case Archive::FORMAT_TAR_USTAR:
+                archive_write_set_format_ustar(ar);
+                break;
+            default:
+                error_msg = "unknown or unsupported archive format";
+                throw Error(error_msg);
+        }
+
+        if(archive_write_open_filename(ar, filename) != ARCHIVE_OK) {
+            error_msg = archive_error_string(ar);
+            throw Error(error_msg);
+        }
+
+    } catch(...) {
+        archive_write_finish(ar);
+        throw;
+    }
+
+    return new Writer(ar);
+}
+
+
+Entry *Writer::new_entry_helper()
+{
+    return new Entry(archive_entry_new());
+}
+
+void Writer::write_header(Entry *entry)
+{
+    if(archive_write_header(_ar, entry->_entry) != ARCHIVE_OK) {
+        std::string error_msg = archive_error_string(_ar);
+        throw Error(error_msg);
+    }
+}
+
+void Writer::write_data_helper(const char *string, int length)
+{
+    if(archive_write_data(_ar, (void*) string, length) == -1) {
+        std::string error_msg = archive_error_string(_ar);
+        throw Error(error_msg);
+    }
+}
+

data/ext/libarchive-ruby-swig/writer.h

@@ -0,0 +1,103 @@
+/*
+ This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+ libarchive.
+
+ Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+ 
+ libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+ license text can be found in the file LICENSE.txt distributed with the source.
+*/
+
+#ifndef CLASS_ARCHIVE_WRITER_H_INCLUDED
+#define CLASS_ARCHIVE_WRITER_H_INCLUDED
+
+struct archive;
+class Entry;
+
+#ifndef SWIG
+#include <ruby.h>
+#endif
+
+namespace Archive
+{
+    enum {
+        FORMAT_AR = 1,
+        FORMAT_AR_BSD,
+        FORMAT_AR_SVR4,
+        FORMAT_CPIO,
+        FORMAT_CPIO_NEWC,
+        FORMAT_MTREE,
+        FORMAT_TAR,
+        FORMAT_TAR_GNUTAR,
+        FORMAT_TAR_PAX_INTERCHANGE,
+        FORMAT_TAR_PAX_RESTRICTED,
+        FORMAT_TAR_USTAR,
+        FORMAT_TAR_OLDTAR,
+        FORMAT_ZIP
+    };
+
+    enum {
+        COMPRESSION_BZIP2 = 1,
+        COMPRESSION_COMPRESS,
+        COMPRESSION_GZIP,
+        COMPRESSION_LZMA,
+        COMPRESSION_NONE,
+        COMPRESSION_XZ
+    };
+};
+
+
+class Writer
+{
+    public:
+        Writer(struct archive *ar);
+        virtual ~Writer();
+        void close();
+
+#ifdef SWIG
+%exception {
+    try {
+        $action
+    } catch(Error &err) {
+        static VALUE c_archive = rb_define_module("Archive");
+        static VALUE e_archive =
+            rb_define_class_under(c_archive, "Error", rb_eStandardError);
+        rb_raise(e_archive, err.what());
+    }
+}
+#endif
+
+#ifdef SWIG
+%newobject write_open_filename(const char *filename,
+    int compression, int format);
+#endif
+
+        static Writer *write_open_filename(const char *filename,
+            int compression, int format);
+
+        void write_header(Entry *entry);
+
+#ifdef SWIG
+%apply (char *STRING, int LENGTH) { (const char *string, int length) };
+#endif
+
+        void write_data_helper(const char *string, int length);
+
+#ifdef SWIG
+%exception;
+#endif
+
+#ifdef SWIG
+%newobject new_entry_helper();
+#endif
+
+        Entry *new_entry_helper();
+
+    private:
+        struct archive *_ar;
+        char *_buf;
+        int _buf_size;
+
+};
+
+#endif

data/lib/libarchive_rs.rb

@@ -0,0 +1,114 @@
+#
+# This file is part of "libarchive-ruby-swig", a simple SWIG wrapper around
+# libarchive.
+#
+# Copyright 2011, Tobias Koch <tobias.koch@gmail.com>
+# 
+# libarchive-ruby-swig is licensed under a simplified BSD License. A copy of the
+# license text can be found in the file LICENSE.txt distributed with the source.
+#
+
+require 'archive'
+
+module Archive
+
+  class Entry
+    alias :file? :is_file
+    alias :directory? :is_directory
+    alias :symbolic_link? :is_symbolic_link
+    alias :block_special? :is_block_special
+    alias :character_special? :is_character_special
+    alias :fifo? :is_fifo
+    alias :socket? :is_socket
+
+    alias :filetype= :set_filetype
+    alias :devmajor= :set_devmajor
+    alias :devminor= :set_devminor
+    alias :atime= :set_atime
+    alias :dev= :set_dev
+    alias :gid= :set_gid
+    alias :gname= :set_gname
+    alias :hardlink= :set_hardlink
+    alias :ino= :set_ino
+    alias :mode= :set_mode
+    alias :mtime= :set_mtime
+    alias :nlink= :set_nlink
+    alias :pathname= :set_pathname
+    alias :rdevmajor= :set_rdevmajor
+    alias :rdevminor= :set_rdevminor
+    alias :size= :set_size
+    alias :symlink= :set_symlink
+    alias :uid= :set_uid
+    alias :uname= :set_uname
+
+    def copy_stat(path)
+      copy_stat_helper(path)
+      self.set_symlink(File.readlink(path)) if self.symbolic_link?
+    end
+
+    private_class_method :new
+  end
+
+  class Reader
+ 
+    def read_data(size)
+      if block_given?
+        while result = self.read_data_helper(size)
+          yield result
+        end
+      else
+        return self.read_data_helper(size)
+      end
+    end
+ 
+    private_class_method :new
+  end
+
+  class Writer
+
+    def new_entry()
+      entry = self.new_entry_helper
+      if block_given?
+        yield entry
+      else
+        return entry
+      end
+    end
+
+    def write_data(data = nil)
+      if block_given?
+        while result = yield
+          self.write_data_helper(result)
+        end
+      else
+        self.write_data_helper(data)
+      end
+    end
+
+    private_class_method :new
+  end
+
+  def self.read_open_filename(filename)
+    ar = Reader.read_open_filename(filename)
+ 
+    if block_given?
+      yield ar
+      ar.close()
+    else
+      return ar
+    end
+  end
+
+  def self.write_open_filename(filename, compression, format)
+    ar = Writer.write_open_filename(filename, compression, format)
+
+    if block_given?
+      yield ar
+      ar.close()
+    else
+      return ar
+    end
+  end
+
+end
+

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: libarchive-ruby-swig
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Tobias Koch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-30 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: libarchive-ruby-swig provides Ruby bindings to libarchive using SWIG. The gem allows you to read and write compressed archives in a variety of formats.
+email: tobias.koch@gmail.com
+executables: []
+
+extensions: 
+- ext/libarchive-ruby-swig/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- lib/libarchive_rs.rb
+- ext/libarchive-ruby-swig/entry.cpp
+- ext/libarchive-ruby-swig/entry.h
+- ext/libarchive-ruby-swig/error.h
+- ext/libarchive-ruby-swig/libarchive.i
+- ext/libarchive-ruby-swig/reader.cpp
+- ext/libarchive-ruby-swig/reader.h
+- ext/libarchive-ruby-swig/writer.cpp
+- ext/libarchive-ruby-swig/writer.h
+- ext/libarchive-ruby-swig/extconf.rb
+has_rdoc: true
+homepage: http://libarchive-rs.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: Libarchive/Ruby/SWIG
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby bindings to libarchive
+test_files: []
+