ffi-libarchive 0.2.0 → 0.4.1

data/lib/ffi-libarchive/entry.rb

@@ -1,7 +1,5 @@
 module Archive
-
   class Entry
-
     S_IFMT   = 0170000
     S_IFSOCK = 0140000 #  socket
     S_IFLNK  = 0120000 #  symbolic link
@@ -19,44 +17,42 @@ module Archive
     CHARACTER_SPECIAL = 0020000 #  character device
     FIFO              = 0010000 #  FIFO
 
-    def self.from_pointer entry
+    def self.from_pointer(entry)
       new entry
     end
 
-    def initialize entry = nil
+    def initialize(entry = nil)
       @entry_free = [true]
       if entry
         @entry = entry
         yield self if block_given?
       else
-        @entry = C::archive_entry_new
+        @entry = C.archive_entry_new
         raise Error, @entry unless @entry
 
         if block_given?
           result = yield self
-          C::archive_entry_free(@entry)
+          C.archive_entry_free(@entry)
           @entry = nil
           return result
         else
           @entry_free[0] = false
-          ObjectSpace.define_finalizer( self, Entry.finalizer(@entry, @entry_free) )
+          ObjectSpace.define_finalizer(self, Entry.finalizer(@entry, @entry_free))
         end
       end
     end
 
-    def self.finalizer entry, entry_free
-      Proc.new do |*args|
-        unless entry_free[0]
-          C::archive_entry_free(entry)
-        end
+    def self.finalizer(entry, entry_free)
+      proc do |*_args|
+        C.archive_entry_free(entry) unless entry_free[0]
       end
     end
 
     def close
       # TODO: do we need synchronization here?
-      if @entry and !@entry_free[0]
+      if @entry && !@entry_free[0]
         @entry_free[0] = true
-        C::archive_entry_free(@entry)
+        C.archive_entry_free(@entry)
       end
     ensure
       @entry = nil
@@ -68,415 +64,411 @@ module Archive
     end
 
     def atime
-      Time.at C::archive_entry_atime(entry)
+      Time.at C.archive_entry_atime(entry)
     end
 
-    def atime= time
+    def atime=(time)
       set_atime time, 0
     end
 
-    def set_atime time, nsec
-      C::archive_entry_set_atime(entry, time.to_i, nsec)
+    def set_atime(time, nsec)
+      C.archive_entry_set_atime(entry, time.to_i, nsec)
     end
 
     def atime_is_set?
-      C::archive_entry_atime_is_set(entry) != 0
+      C.archive_entry_atime_is_set(entry) != 0
     end
 
     def atime_nsec
-      C::archive_entry_atime_nsec(entry)
+      C.archive_entry_atime_nsec(entry)
     end
 
     def birthtime
-      Time.at C::archive_entry_birthtime(entry)
+      Time.at C.archive_entry_birthtime(entry)
     end
 
-    def birthtime= time
+    def birthtime=(time)
       set_birthtime time, 0
     end
 
-    def set_birthtime time, nsec
-      C::archive_entry_set_birthtime(entry, time.to_i, nsec)
+    def set_birthtime(time, nsec)
+      C.archive_entry_set_birthtime(entry, time.to_i, nsec)
     end
 
     def birthtime_is_set?
-      C::archive_entry_birthtime_is_set(entry) != 0
+      C.archive_entry_birthtime_is_set(entry) != 0
     end
 
     def birthtime_nsec
-      C::archive_entry_birthtime_nsec(entry)
+      C.archive_entry_birthtime_nsec(entry)
     end
 
     def ctime
-      Time.at C::archive_entry_ctime(entry)
+      Time.at C.archive_entry_ctime(entry)
     end
 
-    def ctime= time
+    def ctime=(time)
       set_ctime time, 0
     end
 
-    def set_ctime time, nsec
-      C::archive_entry_set_ctime(entry, time.to_i, nsec)
+    def set_ctime(time, nsec)
+      C.archive_entry_set_ctime(entry, time.to_i, nsec)
     end
 
     def ctime_is_set?
-      C::archive_entry_ctime_is_set(entry) != 0
+      C.archive_entry_ctime_is_set(entry) != 0
     end
 
     def ctime_nsec
-      C::archive_entry_ctime_nsec(entry)
+      C.archive_entry_ctime_nsec(entry)
     end
 
     def block_special?
-      C::archive_entry_filetype(entry) & S_IFMT == S_IFBLK
+      C.archive_entry_filetype(entry) & S_IFMT == S_IFBLK
     end
 
     def character_special?
-      C::archive_entry_filetype(entry) & S_IFMT == S_IFCHR
+      C.archive_entry_filetype(entry) & S_IFMT == S_IFCHR
     end
 
     def directory?
-      C::archive_entry_filetype(entry) & S_IFMT == S_IFDIR
+      C.archive_entry_filetype(entry) & S_IFMT == S_IFDIR
     end
 
     def fifo?
-      C::archive_entry_filetype(entry) & S_IFMT == S_IFIFO
+      C.archive_entry_filetype(entry) & S_IFMT == S_IFIFO
     end
 
     def regular?
-      C::archive_entry_filetype(entry) & S_IFMT == S_IFREG
+      C.archive_entry_filetype(entry) & S_IFMT == S_IFREG
     end
-    alias :file? :regular?
+    alias file? regular?
 
     def socket?
-      C::archive_entry_filetype(entry) & S_IFMT == S_IFSOCK
+      C.archive_entry_filetype(entry) & S_IFMT == S_IFSOCK
     end
 
     def symbolic_link?
-      C::archive_entry_filetype(entry) & S_IFMT == S_IFLNK
+      C.archive_entry_filetype(entry) & S_IFMT == S_IFLNK
     end
 
-    def copy_fflags_text fflags_text
-      C::archive_entry_copy_fflags_text(entry, fflags_text)
+    def copy_fflags_text(fflags_text)
+      C.archive_entry_copy_fflags_text(entry, fflags_text)
       nil
     end
 
-    def copy_gname gname
-      C::archive_entry_copy_gname(entry, gname)
+    def copy_gname(gname)
+      C.archive_entry_copy_gname(entry, gname)
       nil
     end
 
-    def copy_hardlink lnk
-      C::archive_entry_copy_hardlink(entry, lnk)
+    def copy_hardlink(lnk)
+      C.archive_entry_copy_hardlink(entry, lnk)
       nil
     end
 
-    def copy_link lnk
-      C::archive_entry_copy_link(entry, lnk)
+    def copy_link(lnk)
+      C.archive_entry_copy_link(entry, lnk)
       nil
     end
 
-    def copy_lstat filename
-      # TODO get this work without ffi-inliner
+    def copy_lstat(filename)
+      # TODO: get this work without ffi-inliner
       begin
         require File.join(Archive::LIBPATH, "ffi-libarchive", "stat")
       rescue => e
         raise "ffi-inliner build for copy_stat failed:\n#{e}"
       end
 
-      stat = Archive::Stat::ffi_libarchive_create_lstat(filename)
-      raise Error, "Copy stat failed: #{Archive::Stat::ffi_error}" if stat.null?
-      result = C::archive_entry_copy_stat(entry, stat)
+      stat = Archive::Stat.ffi_libarchive_create_lstat(filename)
+      raise Error, "Copy stat failed: #{Archive::Stat.ffi_error}" if stat.null?
+      C.archive_entry_copy_stat(entry, stat)
     ensure
-      Archive::Stat::ffi_libarchive_free_stat(stat)
+      Archive::Stat.ffi_libarchive_free_stat(stat)
     end
 
-    def copy_pathname file_name
-      C::archive_entry_copy_pathname(entry, file_name)
+    def copy_pathname(file_name)
+      C.archive_entry_copy_pathname(entry, file_name)
       nil
     end
 
-    def copy_sourcepath path
-      C::archive_copy_sourcepath(entry, path)
+    def copy_sourcepath(path)
+      C.archive_copy_sourcepath(entry, path)
       nil
     end
 
-    def copy_stat filename
-      # TODO get this work without ffi-inliner
+    def copy_stat(filename)
+      # TODO: get this work without ffi-inliner
       begin
         require File.join(Archive::LIBPATH, "ffi-libarchive", "stat")
       rescue => e
         raise "ffi-inliner build for copy_stat failed:\n#{e}"
       end
 
-      stat = Archive::Stat::ffi_libarchive_create_stat(filename)
-      raise Error, "Copy stat failed: #{Archive::Stat::ffi_error}" if stat.null?
-      result = C::archive_entry_copy_stat(entry, stat)
+      stat = Archive::Stat.ffi_libarchive_create_stat(filename)
+      raise Error, "Copy stat failed: #{Archive::Stat.ffi_error}" if stat.null?
+      C.archive_entry_copy_stat(entry, stat)
     ensure
-      Archive::Stat::ffi_libarchive_free_stat(stat)
+      Archive::Stat.ffi_libarchive_free_stat(stat)
     end
 
-    def copy_symlink slnk
-      C::archive_copy_symlink(entry, slnk)
+    def copy_symlink(slnk)
+      C.archive_copy_symlink(entry, slnk)
       nil
     end
 
-    def copy_uname uname
-      C::archive_copy_uname(entry, uname)
+    def copy_uname(uname)
+      C.archive_copy_uname(entry, uname)
       nil
     end
 
     def dev
-      C::archive_entry_dev(entry)
+      C.archive_entry_dev(entry)
     end
 
-    def dev= dev
-      C::archive_entry_set_dev(entry, dev)
+    def dev=(dev)
+      C.archive_entry_set_dev(entry, dev)
     end
 
     def devmajor
-      C::archive_entry_devmajor(entry)
+      C.archive_entry_devmajor(entry)
     end
 
-    def devmajor= dev
-      C::archive_entry_set_devmajor(entry, dev)
+    def devmajor=(dev)
+      C.archive_entry_set_devmajor(entry, dev)
     end
 
     def devminor
-      C::archive_entry_devminor(entry)
+      C.archive_entry_devminor(entry)
     end
 
-    def devminor= dev
-      C::archive_entry_set_devminor(entry, dev)
+    def devminor=(dev)
+      C.archive_entry_set_devminor(entry, dev)
     end
 
     def fflags
       set = FFI::MemoryPointer.new :long
       clear = FFI::MemoryPointer.new :long
-      C::archive_entry_fflags(entry, set, clear)
+      C.archive_entry_fflags(entry, set, clear)
       [set.get_long(0), clear.get_long(0)]
     end
 
     def fflags_text
-      C::archive_entry_fflags_text(entry)
+      C.archive_entry_fflags_text(entry)
     end
 
     def filetype
-      C::archive_entry_filetype(entry)
+      C.archive_entry_filetype(entry)
     end
 
-    def filetype= type
-      if type.kind_of? Symbol
-        type = Entry.const_get type.to_s.upcase.intern
-      end
-      C::archive_entry_set_filetype(entry, type)
+    def filetype=(type)
+      type = Entry.const_get type.to_s.upcase.to_sym if type.is_a? Symbol
+      C.archive_entry_set_filetype(entry, type)
     end
 
     def gid
-      C::archive_entry_gid(entry)
+      C.archive_entry_gid(entry)
     end
 
-    def gid= gid
-      C::archive_entry_set_gid(entry, gid)
+    def gid=(gid)
+      C.archive_entry_set_gid(entry, gid)
     end
 
     def gname
-      C::archive_entry_gname(entry)
+      C.archive_entry_gname(entry)
     end
 
-    def gname= gname
-      C::archive_entry_set_gname(entry, gname)
+    def gname=(gname)
+      C.archive_entry_set_gname(entry, gname)
     end
 
     def hardlink
-      C::archive_entry_hardlink(entry)
+      C.archive_entry_hardlink(entry)
     end
 
-    def hardlink= lnk
-      C::archive_entry_set_hardlink(entry, lnk)
+    def hardlink=(lnk)
+      C.archive_entry_set_hardlink(entry, lnk)
     end
 
     def ino
-      C::archive_entry_ino(entry)
+      C.archive_entry_ino(entry)
     end
 
-    def ino= ino
-      C::archive_entry_set_ino(entry, ino)
+    def ino=(ino)
+      C.archive_entry_set_ino(entry, ino)
     end
 
-    def link= lnk
-      C::archive_entry_set_link(entry, lnk)
+    def link=(lnk)
+      C.archive_entry_set_link(entry, lnk)
     end
 
     def mode
-      C::archive_entry_mode(entry)
+      C.archive_entry_mode(entry)
     end
 
-    def mode= mode
-      C::archive_entry_set_mode(entry, mode)
+    def mode=(mode)
+      C.archive_entry_set_mode(entry, mode)
     end
 
     def mtime
-      Time.at C::archive_entry_mtime(entry)
+      Time.at C.archive_entry_mtime(entry)
     end
 
-    def mtime= time
+    def mtime=(time)
       set_mtime time, 0
     end
 
-    def set_mtime time, nsec
-      C::archive_entry_set_mtime(entry, time.to_i, nsec)
+    def set_mtime(time, nsec)
+      C.archive_entry_set_mtime(entry, time.to_i, nsec)
     end
 
     def mtime_is_set?
-      C::archive_entry_mtime_is_set(entry) != 0
+      C.archive_entry_mtime_is_set(entry) != 0
     end
 
     def mtime_nsec
-      C::archive_entry_mtime_nsec(entry)
+      C.archive_entry_mtime_nsec(entry)
     end
 
     def nlink
-      C::archive_entry_nlink(entry)
+      C.archive_entry_nlink(entry)
     end
 
-    def nlink= nlink
-      C::archive_entry_set_nlink(entry, nlink)
+    def nlink=(nlink)
+      C.archive_entry_set_nlink(entry, nlink)
     end
 
     def pathname
-      C::archive_entry_pathname(entry)
+      C.archive_entry_pathname(entry)
     end
 
-    def pathname= path
-      C::archive_entry_set_pathname(entry, path)
+    def pathname=(path)
+      C.archive_entry_set_pathname(entry, path)
     end
 
-    def perm= perm
-      C::archive_entry_set_perm(entry, perm)
+    def perm=(perm)
+      C.archive_entry_set_perm(entry, perm)
     end
 
     def rdev
-      C::archive_entry_rdev(entry)
+      C.archive_entry_rdev(entry)
     end
 
-    def rdev= dev
-      C::archive_entry_set_rdev(entry, dev)
+    def rdev=(dev)
+      C.archive_entry_set_rdev(entry, dev)
     end
 
     def rdevmajor
-      C::archive_entry_rdevmajor(entry)
+      C.archive_entry_rdevmajor(entry)
     end
 
-    def rdevmajor= dev
-      C::archive_entry_set_rdevmajor(entry, dev)
+    def rdevmajor=(dev)
+      C.archive_entry_set_rdevmajor(entry, dev)
     end
 
     def rdevminor
-      C::archive_entry_rdevminor(entry)
+      C.archive_entry_rdevminor(entry)
     end
 
-    def rdevminor= dev
-      C::archive_entry_set_rdevminor(entry, dev)
+    def rdevminor=(dev)
+      C.archive_entry_set_rdevminor(entry, dev)
     end
 
-    def set_fflags set, clear
-      C::archive_entry_set_fflags(entry, set, clear)
+    def set_fflags(set, clear)
+      C.archive_entry_set_fflags(entry, set, clear)
     end
 
     def size
-      C::archive_entry_size(entry)
+      C.archive_entry_size(entry)
     end
 
-    def size= size
-      C::archive_entry_set_size(entry, size)
+    def size=(size)
+      C.archive_entry_set_size(entry, size)
     end
 
     def size_is_set?
-      C::archive_entry_size_is_set(entry) != 0
+      C.archive_entry_size_is_set(entry) != 0
     end
 
     def sourcepath
-      C::archive_entry_sourcepath(entry)
+      C.archive_entry_sourcepath(entry)
     end
 
     def strmode
-      C::archive_entry_strmode(entry)
+      C.archive_entry_strmode(entry)
     end
 
     def symlink
-      C::archive_entry_symlink(entry)
+      C.archive_entry_symlink(entry)
     end
 
-    def symlink= slnk
-      C::archive_entry_set_symlink(entry, slnk)
+    def symlink=(slnk)
+      C.archive_entry_set_symlink(entry, slnk)
     end
 
     def uid
-      C::archive_entry_uid(entry)
+      C.archive_entry_uid(entry)
     end
 
-    def uid= uid
-      C::archive_entry_set_uid(entry, uid)
+    def uid=(uid)
+      C.archive_entry_set_uid(entry, uid)
     end
 
     def uname
-      C::archive_entry_uname(entry)
+      C.archive_entry_uname(entry)
     end
 
-    def uname= uname
-      C::archive_entry_set_uname(entry, uname)
+    def uname=(uname)
+      C.archive_entry_set_uname(entry, uname)
     end
 
     def unset_atime
-      C::archive_entry_unset_atime(entry)
+      C.archive_entry_unset_atime(entry)
     end
 
     def unset_birthtime
-      C::archive_entry_unset_birthtime(entry)
+      C.archive_entry_unset_birthtime(entry)
     end
 
     def unset_ctime
-      C::archive_entry_unset_ctime(entry)
+      C.archive_entry_unset_ctime(entry)
     end
 
     def unset_mtime
-      C::archive_entry_unset_mtime(entry)
+      C.archive_entry_unset_mtime(entry)
     end
 
     def unset_size
-      C::archive_entry_unset_size(entry)
+      C.archive_entry_unset_size(entry)
     end
 
-    def xattr_add_entry name, value
-      C::archive_entry_xattr_add_entry(entry, name, value, value.size)
+    def xattr_add_entry(name, value)
+      C.archive_entry_xattr_add_entry(entry, name, value, value.size)
     end
 
     def xattr_clear
-      C::archive_entry_xattr_clear(entry)
+      C.archive_entry_xattr_clear(entry)
     end
 
     def xattr_count
-      C::archive_entry_xattr_count(entry)
+      C.archive_entry_xattr_count(entry)
     end
 
     def xattr_next
       name = FFI::MemoryPointer.new :pointer
       value = FFI::MemoryPointer.new :pointer
       size = FFI::MemoryPointer.new :size_t
-      if C::archive_entry_xattr_next(entry, name, value, size) != C::OK
+      if C.archive_entry_xattr_next(entry, name, value, size) != C::OK
         return nil
       else
         # TODO: someday size.read_size_t could work
         return [name.null? ? nil : name.read_string,
-                value.null? ? nil : value.get_string(0,size.read_ulong)]
+                value.null? ? nil : value.get_string(0, size.read_ulong)]
       end
     end
 
     def xattr_reset
-      C::archive_entry_xattr_reset(entry)
+      C.archive_entry_xattr_reset(entry)
     end
-
   end
-
 end