ffi-libarchive 0.1.4 → 0.2.0

data/lib/ffi-libarchive/reader.rb

@@ -1,127 +1,127 @@
 module Archive
 
-    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
+  class Reader < BaseArchive
+
+    private_class_method :new
 
-        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
+    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 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.bytesize + 1)
-                @data.write_string str, str.bytesize
-                raise Error, @archive if C::archive_read_open_memory(archive, @data, str.bytesize) != C::OK
-            end
-        rescue
-            close
-            raise
+    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 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
+    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.bytesize + 1)
+        @data.write_string str, str.bytesize
+        raise Error, @archive if C::archive_read_open_memory(archive, @data, str.bytesize) != C::OK
+      end
+    rescue
+      close
+      raise
+    end
 
-            flags &= EXTRACT_FLAGS
-            raise Error, @archive if C::archive_read_extract(archive, entry, flags) != C::OK
-        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 flags.kind_of? Integer
 
-        def header_position
-            raise Error, @archive if C::archive_read_header_position archive
-        end
+      flags &= EXTRACT_FFLAGS
+      raise Error, @archive if C::archive_read_extract(archive, entry.entry, flags) != C::OK
+    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 header_position
+      raise Error, @archive if C::archive_read_header_position archive
+    end
 
-        def each_entry
-            while entry = next_header
-                yield entry
-            end
-        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_with_data( size = C::DATA_BUFFER_SIZE )
-            while entry = next_header
-                yield entry, read_data
-            end
-        end
+    def each_entry
+      while entry = next_header
+        yield entry
+      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::MemoryPointer.new(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 each_entry_with_data( size = C::DATA_BUFFER_SIZE )
+      while entry = next_header
+        yield entry, read_data
+      end
+    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
+    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::MemoryPointer.new(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

@@ -1,38 +1,38 @@
 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.include 'string.h'
-            builder.include 'errno.h'
-            builder.c %q{
+  module Stat
+    extend Inliner
+    inline do |builder|
+      builder.include 'stdlib.h'
+      builder.include 'sys/types.h'
+      builder.include 'sys/stat.h'
+      builder.include 'string.h'
+      builder.include 'errno.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{
+      }
+      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{
+      }
+      builder.c %q{
                  void ffi_libarchive_free_stat(void* s) {
                      free((struct stat*)s);
                  }
-            }
-            builder.c %q{
+      }
+      builder.c %q{
                  const char* ffi_error() {
                      return strerror(errno);
                  }
-            }
-        end
+      }
     end
+  end
 end

data/lib/ffi-libarchive/version.rb

@@ -0,0 +1,3 @@
+module Archive
+  VERSION = '0.2.0'
+end

data/lib/ffi-libarchive/writer.rb

@@ -1,140 +1,140 @@
 module Archive
 
-    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
+  class Writer < BaseArchive
 
-        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
+    private_class_method :new
 
-        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]
-                if C::archive_write_get_bytes_in_last_block(@archive) == -1
-                    C::archive_write_set_bytes_in_last_block(archive, 1)
-                end
-                @data = write_callback params[:memory]
-                raise Error, @archive if C::archive_write_open(archive, nil,
-                                                               nil,
-                                                               @data,
-                                                               nil) != C::OK
-            end
-        rescue => e
-            close
-            raise
+    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 write_callback data
-            Proc.new { |ar, client, buffer, length|
-                data.concat buffer.get_bytes(0,length)
-                length
-            }
+    def self.open_memory string, compression, format
+      if block_given?
+        writer = open_memory string, compression, format
+        begin
+          yield writer
+        ensure
+          writer.close
         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
+      else
+        if compression.kind_of? String
+          command = compression
+          compression = -1
+        else
+          command = nil
         end
+        new :memory => string, :compression => compression, :format => format
+      end
+    end
 
-        def add_entry &block
-            raise ArgumentError, "No block given" unless block_given?
-
-            entry = Entry.new
-            data = yield entry
-            if data
-                entry.size = data.bytesize
-                write_header entry
-                write_data data
-            else
-                write_header entry
-            end
-            nil
-        ensure
-            entry.close
+    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]
+        if C::archive_write_get_bytes_in_last_block(@archive) == -1
+          C::archive_write_set_bytes_in_last_block(archive, 1)
         end
+        @data = write_callback params[:memory]
+        raise Error, @archive if C::archive_write_open(archive, nil,
+                                                       nil,
+                                                       @data,
+                                                       nil) != C::OK
+      end
+    rescue => e
+      close
+      raise
+    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.bytesize)) < 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.bytesize)
-            end
+    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
+      if data
+        entry.size = data.bytesize
+        write_header entry
+        write_data data
+      else
+        write_header entry
+      end
+      nil
+    ensure
+      entry.close
+    end
 
-        def write_header entry
-            raise Error, @archive if C::archive_write_header(archive, entry.entry) != C::OK
+    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.bytesize)) < 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.bytesize)
+      end
+    end
 
+    def write_header entry
+      raise Error, @archive if C::archive_write_header(archive, entry.entry) != C::OK
     end
 
+  end
+
 end