ffi-libarchive 0.2.0 → 0.4.1

data/lib/ffi-libarchive/reader.rb

@@ -1,10 +1,8 @@
 module Archive
-
   class Reader < BaseArchive
-
     private_class_method :new
 
-    def self.open_filename file_name, command = nil
+    def self.open_filename(file_name, command = nil)
       if block_given?
         reader = open_filename file_name, command
         begin
@@ -13,11 +11,11 @@ module Archive
           reader.close
         end
       else
-        new :file_name => file_name, :command => command
+        new file_name: file_name, command: command
       end
     end
 
-    def self.open_memory string, command = nil
+    def self.open_memory(string, command = nil)
       if block_given?
         reader = open_memory string, command
         begin
@@ -26,50 +24,50 @@ module Archive
           reader.close
         end
       else
-        new :memory => string, :command => command
+        new memory: string, command: command
       end
     end
 
-    def initialize params = {}
-      super C::method(:archive_read_new), C::method(:archive_read_finish)
+    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
+        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
+        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
+      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
+        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
+        raise Error, @archive if C.archive_read_open_memory(archive, @data, str.bytesize) != 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 flags.kind_of? Integer
+    def extract(entry, flags = 0)
+      raise ArgumentError, "Expected Archive::Entry as first argument" unless entry.is_a? Entry
+      raise ArgumentError, "Expected Integer as second argument" unless flags.is_a? Integer
 
       flags &= EXTRACT_FFLAGS
-      raise Error, @archive if C::archive_read_extract(archive, entry.entry, flags) != C::OK
+      raise Error, @archive if C.archive_read_extract(archive, entry.entry, flags) != C::OK
     end
 
     def header_position
-      raise Error, @archive if C::archive_read_header_position archive
+      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)
+      case C.archive_read_next_header(archive, entry_ptr)
       when C::OK
         Entry.from_pointer entry_ptr.read_pointer
       when C::EOF
@@ -81,34 +79,35 @@ module Archive
     end
 
     def each_entry
-      while entry = next_header
+      while (entry = next_header)
         yield entry
       end
     end
 
-    def each_entry_with_data( size = C::DATA_BUFFER_SIZE )
-      while entry = next_header
+    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
+    def read_data(size = C::DATA_BUFFER_SIZE)
+      raise ArgumentError, "Buffer size must be > 0 (was: #{size})" unless size.is_a?(Integer) && 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
+      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)
+          if block_given?
+            yield buffer.get_bytes(0, n)
+          else
+            data ||= ""
+            data.concat(buffer.get_bytes(0, n))
+          end
         end
         len += n
       end
@@ -116,12 +115,10 @@ module Archive
       data || len
     end
 
-    def save_data file_name
+    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
+        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'
+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{
+      builder.include "stdlib.h"
+      builder.include "sys/types.h"
+      builder.include "sys/stat.h"
+      builder.include "string.h"
+      builder.include "errno.h"
+      builder.c '
                  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 '
                  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 '
                  void ffi_libarchive_free_stat(void* s) {
                      free((struct stat*)s);
                  }
-      }
-      builder.c %q{
+      '
+      builder.c '
                  const char* ffi_error() {
                      return strerror(errno);
                  }
-      }
+      '
     end
   end
 end

data/lib/ffi-libarchive/version.rb

@@ -1,3 +1,3 @@
 module Archive
-  VERSION = '0.2.0'
+  VERSION = "0.4.1".freeze
 end

data/lib/ffi-libarchive/writer.rb

@@ -1,10 +1,8 @@
 module Archive
-
   class Writer < BaseArchive
-
     private_class_method :new
 
-    def self.open_filename file_name, compression, format
+    def self.open_filename(file_name, compression, format)
       if block_given?
         writer = open_filename file_name, compression, format
         begin
@@ -13,11 +11,11 @@ module Archive
           writer.close
         end
       else
-        new :file_name => file_name, :compression => compression, :format => format
+        new file_name: file_name, compression: compression, format: format
       end
     end
 
-    def self.open_memory string, compression, format
+    def self.open_memory(string, compression, format)
       if block_given?
         writer = open_memory string, compression, format
         begin
@@ -26,57 +24,54 @@ module Archive
           writer.close
         end
       else
-        if compression.kind_of? String
-          command = compression
+        if compression.is_a? String
           compression = -1
-        else
-          command = nil
         end
-        new :memory => string, :compression => compression, :format => format
+        new memory: string, compression: compression, format: format
       end
     end
 
-    def initialize params = {}
-      super C::method(:archive_write_new), C::method(:archive_write_finish)
+    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)
+        compression = Archive.const_get("COMPRESSION_#{compression.to_s.upcase}".to_sym)
       end
 
       format = params[:format]
       case format
       when Symbol
-        format = Archive::const_get("FORMAT_#{format.to_s.upcase}".intern)
+        format = Archive.const_get("FORMAT_#{format.to_s.upcase}".to_sym)
       end
 
-      raise Error, @archive if C::archive_write_set_compression(archive, compression) != C::OK
+      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
+      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
+        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)
+        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,
+        raise Error, @archive if C.archive_write_open(archive, nil,
                                                        nil,
                                                        @data,
                                                        nil) != C::OK
       end
-    rescue => e
+    rescue
       close
       raise
     end
 
-    def write_callback data
-      Proc.new { |ar, client, buffer, length|
-        data.concat buffer.get_bytes(0,length)
+    def write_callback(data)
+      proc do |_ar, _client, buffer, length|
+        data.concat buffer.get_bytes(0, length)
         length
-      }
+      end
     end
     private :write_callback
 
@@ -94,7 +89,7 @@ module Archive
       end
     end
 
-    def add_entry &block
+    def add_entry
       raise ArgumentError, "No block given" unless block_given?
 
       entry = Entry.new
@@ -111,15 +106,15 @@ module Archive
       entry.close
     end
 
-    def write_data *args
+    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
+        loop do
           str = yield
-          if ((n = C::archive_write_data(ar, str, str.bytesize)) < 1)
+          if (n = C.archive_write_data(ar, str, str.bytesize)) < 1
             return len
           end
           len += n
@@ -127,14 +122,12 @@ module Archive
       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)
+        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
+    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

@@ -1,119 +1,117 @@
-require 'ffi-libarchive'
-require 'tmpdir'
-require 'test/unit'
+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".b ],
-         ['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!".b ],
-         ['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".b ]
-        ]
-
-    def setup
-        File.open('data/test.tar.gz', 'rb') do |f|
-            @archive_content = f.read
-        end
+  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".b ],
+       ["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!".b ],
+       ["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".b ]
+      ]
+
+  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
+  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
+  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
+  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
+  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
+  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
+    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
+    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|
+        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|
+        ar.next_header
+        data = ""
+        ar.read_data(128) { |chunk| data += chunk }
+
+        assert_equal content, data
+      end
     end
+  end
 
-    private
+  private
 
-    def verify_content(ar)
-        content_spec_idx = 0
+  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]
+    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)
+      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
+      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
+      content_spec_idx += 1
     end
+  end
 
 end