ffi-libarchive 0.1.0

data/lib/ffi-libarchive/reader.rb

@@ -0,0 +1,131 @@
+module Archive
+
+    # TODO: Remove this forward-declaration
+    class BaseArchive
+    end
+
+    class Reader < BaseArchive
+
+        private_class_method :new
+
+        def self.open_filename file_name, command = nil
+            if block_given?
+                reader = open_filename file_name, command
+                begin
+                    yield reader
+                ensure
+                    reader.close
+                end
+            else
+                new :file_name => file_name, :command => command
+            end
+        end
+
+        def self.open_memory string, command = nil
+            if block_given?
+                reader = open_memory string, command
+                begin
+                    yield reader
+                ensure
+                    reader.close
+                end
+            else
+                new :memory => string, :command => command
+            end
+        end
+
+        def initialize params = {}
+            super C::method(:archive_read_new), C::method(:archive_read_finish)
+
+            if params[:command]
+                cmd = params[:command]
+                raise Error, @archive if C::archive_read_support_compression_program(archive, cmd) != C::OK
+            else
+                raise Error, @archive if C::archive_read_support_compression_all(archive) != C::OK
+            end
+
+            raise Error, @archive if C::archive_read_support_format_all(archive) != C::OK
+
+            if params[:file_name]
+                raise Error, @archive if C::archive_read_open_filename(archive, params[:file_name], 1024) != C::OK
+            elsif params[:memory]
+                str = params[:memory]
+                @data = FFI::MemoryPointer.new str.size
+                @data.put_bytes 0, str
+                raise Error, @archive if C::archive_read_open_memory(archive, @data, @data.size) != C::OK
+            end
+        rescue
+            close
+            raise
+        end
+
+        def extract entry, flags = 0
+            raise ArgumentError, "Expected Archive::Entry as first argument" unless entry.kind_of? Entry
+            raise ArgumentError, "Expected Integer as second argument" unless entry.kind_of? Integer
+
+            flags &= EXTRACT_FLAGS
+            raise Error, @archive if C::archive_read_extract(archive, entry, flags) != C::OK
+        end
+
+        def header_position
+            raise Error, @archive if C::archive_read_header_position archive
+        end
+
+        def next_header
+            entry_ptr = FFI::MemoryPointer.new(:pointer)
+            case C::archive_read_next_header(archive, entry_ptr)
+            when C::OK
+                Entry.from_pointer entry_ptr.read_pointer
+            when C::EOF
+                @eof = true
+                nil
+            else
+                raise Error, @archive
+            end
+        end
+
+        def each_entry
+            while entry = next_header
+                yield entry
+            end
+        end
+
+        def each_entry_with_data( size = C::DATA_BUFFER_SIZE )
+            while entry = next_header
+                yield entry, read_data
+            end
+        end
+
+        def read_data size = C::DATA_BUFFER_SIZE, &block
+            raise ArgumentError, "Buffer size must be > 0 (was: #{size})" unless size.kind_of?(Integer) and size > 0
+
+            data = nil
+            unless block
+                data = ""
+                block = data.method :concat
+            end
+
+            buffer = FFI::Buffer.alloc_out(size)
+            len = 0
+            while (n = C::archive_read_data(archive, buffer, size)) > 0
+                case n
+                when C::FATAL, C::WARN, C::RETRY
+                    raise Error, @archive
+                else
+                    block.call buffer.get_bytes(0,n)
+                end
+                len += n
+            end
+
+            data || len
+        end
+
+        def save_data file_name
+            IO.sysopen(file_name, "wb") do |fd|
+                raise Error, @archive if C::archive_read_data_into_fd(archive, fd) != C::OK
+            end
+        end
+
+    end
+
+end

data/lib/ffi-libarchive/stat.rb

@@ -0,0 +1,31 @@
+require 'ffi-inliner'
+
+module Archive
+    module Stat
+        extend Inliner
+        inline do |builder|
+            builder.include 'stdlib.h'
+            builder.include 'sys/types.h'
+            builder.include 'sys/stat.h'
+            builder.c %q{
+                 void* ffi_libarchive_create_stat(const char* filename) {
+                     struct stat* s = malloc(sizeof(struct stat));
+                     if (stat(filename, s) != 0) return NULL;
+                     return s;
+                 }
+            }
+            builder.c %q{
+                 void* ffi_libarchive_create_lstat(const char* filename) {
+                     struct stat* s = malloc(sizeof(struct stat));
+                     lstat(filename, s);
+                     return s;
+                 }
+            }
+            builder.c %q{
+                 void ffi_libarchive_free_stat(void* s) {
+                     free((struct stat*)s);
+                 }
+            }
+        end
+    end
+end

data/lib/ffi-libarchive/writer.rb

@@ -0,0 +1,143 @@
+module Archive
+
+    # TODO: Remove this forward-declaration
+    class BaseArchive
+    end
+
+    class Writer < BaseArchive
+
+        private_class_method :new
+
+        def self.open_filename file_name, compression, format
+            if block_given?
+                writer = open_filename file_name, compression, format
+                begin
+                    yield writer
+                ensure
+                    writer.close
+                end
+            else
+                new :file_name => file_name, :compression => compression, :format => format
+            end
+        end
+
+        def self.open_memory string, compression, format
+            if block_given?
+                writer = open_memory string, compression, format
+                begin
+                    yield writer
+                ensure
+                    writer.close
+                end
+            else
+                if compression.kind_of? String
+                    command = compression
+                    compression = -1
+                else
+                    command = nil
+                end
+                new :memory => string, :compression => compression, :format => format
+            end
+        end
+
+        def initialize params = {}
+            super C::method(:archive_write_new), C::method(:archive_write_finish)
+
+            compression = params[:compression]
+            case compression
+            when Symbol
+                compression = Archive::const_get("COMPRESSION_#{compression.to_s.upcase}".intern)
+            end
+
+            format = params[:format]
+            case format
+            when Symbol
+                format = Archive::const_get("FORMAT_#{format.to_s.upcase}".intern)
+            end
+
+            raise Error, @archive if C::archive_write_set_compression(archive, compression) != C::OK
+
+            raise Error, @archive if C::archive_write_set_format(archive, format) != C::OK
+
+            if params[:file_name]
+                raise Error, @archive if C::archive_write_open_filename(archive, params[:file_name]) != C::OK
+            elsif params[:memory]
+                @data = write_callback params[:memory]
+                raise Error, @archive if C::archive_write_open(archive, nil,
+                                                               method(:open_callback),
+                                                               @data,
+                                                               nil) != C::OK
+            end
+        rescue => e
+            close
+            raise
+        end
+
+        def open_callback archive, client
+            if C::archive_write_get_bytes_in_last_block(archive) == -1
+                C::archive_write_set_bytes_in_last_block(archive, 1)
+            end
+            C::OK
+        end
+        private :open_callback
+
+        def write_callback data
+            Proc.new { |ar, client, buffer, length|
+                data.concat buffer.get_bytes(0,length)
+                length
+            }
+        end
+        private :write_callback
+
+        def new_entry
+            entry = Entry.new
+            if block_given?
+                begin
+                    result = yield entry
+                ensure
+                    entry.close
+                end
+                result
+            else
+                entry
+            end
+        end
+
+        def add_entry &block
+            raise ArgumentError, "No block given" unless block_given?
+
+            entry = Entry.new
+            data = yield entry
+            write_header entry
+            write_data data if data
+        ensure
+            entry.close
+        end
+
+        def write_data *args
+            if block_given?
+                raise ArgumentError, "wrong number of argument (#{args.size} for 0)" if args.size > 0
+
+                ar = archive
+                len = 0
+                while true do
+                    str = yield
+                    if ((n = C::archive_write_data(ar, str, str.size)) < 1)
+                        return len
+                    end
+                    len += n
+                end
+            else
+                raise ArgumentError, "wrong number of argument (#{args.size}) for 1)" if args.size != 1
+                str = args[0]
+                C::archive_write_data(archive, str, str.size)
+            end
+        end
+
+        def write_header entry
+            raise Error, @archive if C::archive_write_header(archive, entry.entry) != C::OK
+        end
+
+    end
+
+end

data/test/sets/ts_read.rb

@@ -0,0 +1,119 @@
+require 'ffi-libarchive'
+require 'tmpdir'
+require 'test/unit'
+
+class TS_ReadArchive < Test::Unit::TestCase
+
+    CONTENT_SPEC =
+        [
+         ['test/', 'directory', 0755, nil ],
+         ['test/b/', 'directory', 0755, nil ],
+         ['test/b/c/', 'directory', 0755, nil ],
+         ['test/b/c/c.dat', 'file', 0600, "\266\262\v_\266\243\305\3601\204\277\351\354\265\003\036\036\365f\377\210\205\032\222\346\370b\360u\032Y\301" ],
+         ['test/b/c/d/', 'directory', 0711, nil ],
+         ['test/b/c/d/d.dat', 'symbolic_link', 0777, "../c.dat" ],
+         ['test/b/b.dat', 'file', 0640, "s&\245\354(M\331=\270\000!s\355\240\252\355'N\304\343\bY\317\t\274\210\3128\321\347\234!" ],
+         ['test/a.dat', 'file', 0777, "\021\216\231Y\354\236\271\372\336\213\224R\211{D{\277\262\304\211xu\330\\\275@~\035\vSRM" ]
+        ]
+
+    def setup
+        File.open('data/test.tar.gz', 'rb') do |f|
+            @archive_content = f.read
+        end
+    end
+
+
+    def test_read_tar_gz_from_file
+        Archive.read_open_filename('data/test.tar.gz') do |ar|
+            verify_content(ar)
+        end
+    end
+
+    def test_read_tar_gz_from_file_with_external_gunzip
+        Archive.read_open_filename('data/test.tar.gz', 'gunzip') do |ar|
+            verify_content(ar)
+        end
+    end
+
+    def test_read_tar_gz_from_memory
+        Archive.read_open_memory(@archive_content) do |ar|
+            verify_content(ar)
+        end
+    end
+
+    def test_read_tar_gz_from_memory_with_external_gunzip
+        Archive.read_open_memory(@archive_content, 'gunzip') do |ar|
+            verify_content(ar)
+        end
+    end
+
+    def test_read_entry_bigger_than_internal_buffer
+        alphabet = "abcdefghijklmnopqrstuvwxyz"
+        entry_size = 1024 * 4 - 3
+
+        srand
+        content = ""
+        1.upto(entry_size) do |i|
+            index = rand(alphabet.size)
+            content += alphabet[index,1]
+        end
+
+        Dir.mktmpdir do |dir|
+            Archive.write_open_filename(dir + '/test.tar.gz',
+                                        Archive::COMPRESSION_BZIP2, Archive::FORMAT_TAR) do |ar|
+                ar.new_entry do |entry|
+                    entry.pathname = "chubby.dat"
+                    entry.mode = 0666
+                    entry.filetype = Archive::Entry::FILE
+                    entry.atime = Time.now.to_i
+                    entry.mtime = Time.now.to_i
+                    entry.size = entry_size
+                    ar.write_header(entry)
+                    ar.write_data(content)
+                end
+            end
+
+            Archive.read_open_filename(dir + '/test.tar.gz') do |ar|
+                entry = ar.next_header
+                data = ar.read_data
+
+                assert_equal entry_size, data.size
+                assert_equal content.size, data.size
+                assert_equal content, data
+            end
+
+            Archive.read_open_filename(dir + '/test.tar.gz') do |ar|
+                entry = ar.next_header
+                data = ""
+                ar.read_data(128) { |chunk| data += chunk }
+
+                assert_equal content, data
+            end
+        end
+    end
+
+    private
+
+    def verify_content(ar)
+        content_spec_idx = 0
+
+        while entry = ar.next_header
+            expect_pathname, expect_type, expect_mode, expect_content =\
+            CONTENT_SPEC[content_spec_idx]
+
+            assert_equal expect_pathname, entry.pathname
+            assert_equal entry.send("#{expect_type}?"), true
+            assert_equal expect_mode, (entry.mode & 07777)
+
+            if entry.symbolic_link?
+                assert_equal expect_content, entry.symlink
+            elsif entry.file?
+                content = ar.read_data(1024)
+                assert_equal expect_content, content
+            end
+
+            content_spec_idx += 1
+        end
+    end
+
+end

data/test/sets/ts_write.rb

@@ -0,0 +1,133 @@
+require 'ffi-libarchive'
+require 'tmpdir'
+require 'test/unit'
+
+class TS_WriteArchive < Test::Unit::TestCase
+
+    CONTENT_SPEC =
+        [
+         ['test/', 'directory', 0755, nil ],
+         ['test/b/', 'directory', 0755, nil ],
+         ['test/b/c/', 'directory', 0755, nil ],
+         ['test/b/c/c.dat', 'file', 0600, "\266\262\v_\266\243\305\3601\204\277\351\354\265\003\036\036\365f\377\210\205\032\222\346\370b\360u\032Y\301" ],
+         ['test/b/c/d/', 'directory', 0711, nil ],
+         ['test/b/c/d/d.dat', 'symbolic_link', 0777, "../c.dat" ],
+         ['test/b/b.dat', 'file', 0640, "s&\245\354(M\331=\270\000!s\355\240\252\355'N\304\343\bY\317\t\274\210\3128\321\347\234!" ],
+         ['test/a.dat', 'file', 0777, "\021\216\231Y\354\236\271\372\336\213\224R\211{D{\277\262\304\211xu\330\\\275@~\035\vSRM" ]
+        ]
+
+    def test_end_to_end_write_read_tar_gz
+        Dir.mktmpdir do |dir|
+            Archive.write_open_filename(dir + '/test.tar.gz', :gzip, :tar) do |ar|
+                write_content(ar)
+            end
+
+            verify_content(dir + '/test.tar.gz')
+        end
+    end
+
+    def test_end_to_end_write_read_memory
+        memory = ""
+        Archive.write_open_memory(memory, Archive::COMPRESSION_GZIP, Archive::FORMAT_TAR) do |ar|
+            write_content ar
+        end
+        verify_content_memory(memory)
+    end
+
+    def test_end_to_end_write_read_tar_gz_with_external_gzip
+        Dir.mktmpdir do |dir|
+            Archive.write_open_filename(dir + '/test.tar.gz', 'gzip', :tar) do |ar|
+                write_content(ar)
+            end
+
+            verify_content(dir + '/test.tar.gz')
+        end
+    end
+
+    def test_end_to_end_write_read_tar_gz
+        Dir.mktmpdir do |dir|
+            Archive.write_open_filename(dir + '/test.tar.gz', :gzip, :tar) do |ar|
+                write_content(ar)
+            end
+
+            verify_content(dir + '/test.tar.gz')
+        end
+    end
+
+    private
+
+    def write_content(ar)
+        content_spec_idx = 0
+
+        while content_spec_idx < CONTENT_SPEC.size()
+            entry_path, entry_type, entry_mode, entry_content = \
+            CONTENT_SPEC[content_spec_idx]
+
+            ar.new_entry do |entry|
+                entry.pathname = entry_path
+                entry.mode = entry_mode
+                entry.filetype = eval "Archive::Entry::#{entry_type.upcase}"
+                entry.size = entry_content.size if entry_content
+                entry.symlink = entry_content if entry_type == 'symbolic_link'
+                entry.atime = Time.now.to_i
+                entry.mtime = Time.now.to_i
+                ar.write_header(entry)
+
+                if entry_type == 'file'
+                    ar.write_data(entry_content)
+                end
+            end
+
+            content_spec_idx += 1
+        end
+    end
+
+    def verify_content_memory(memory)
+        Archive.read_open_memory(memory) do |ar|
+            content_spec_idx = 0
+
+            while entry = ar.next_header
+                expect_pathname, expect_type, expect_mode, expect_content =\
+                CONTENT_SPEC[content_spec_idx]
+
+                assert_equal expect_pathname, entry.pathname
+                assert_equal entry.send("#{expect_type}?"), true
+                assert_equal expect_mode, (entry.mode & 07777)
+
+                if entry.symbolic_link?
+                    assert_equal expect_content, entry.symlink
+                elsif entry.file?
+                    content = ar.read_data(1024)
+                    assert_equal expect_content, content
+                end
+
+                content_spec_idx += 1
+            end
+        end
+    end
+
+    def verify_content(filename)
+        Archive.read_open_filename(filename) do |ar|
+            content_spec_idx = 0
+
+            while entry = ar.next_header
+                expect_pathname, expect_type, expect_mode, expect_content =\
+                CONTENT_SPEC[content_spec_idx]
+
+                assert_equal expect_pathname, entry.pathname
+                assert_equal entry.send("#{expect_type}?"), true
+                assert_equal expect_mode, (entry.mode & 07777)
+
+                if entry.symbolic_link?
+                    assert_equal expect_content, entry.symlink
+                elsif entry.file?
+                    content = ar.read_data(1024)
+                    assert_equal expect_content, content
+                end
+
+                content_spec_idx += 1
+            end
+        end
+    end
+
+end