win32-file-stat 1.2.3

data/CHANGES

@@ -0,0 +1,32 @@
+== 1.2.3 - 4-Nov-2006
+* Bug fix for file sizes over 4gb.
+
+== 1.2.2 - 13-May-2006
+* Yet another blksize bug fix.
+* Minor tweak to the pretty_print method with regards to handling nil values.
+* Bumped the minimum required windows-pr version to 0.4.0 in the gemspec.
+
+== 1.2.1 - 12-May-2006
+* Fixed a bug with regards to the block count where the constructor would die
+  with a FloatDomainError if the blksize returned 0 or nil.  It now defaults
+  to nil in that event.
+
+== 1.2.0 - 23-Apr-2006
+* Removed the attribute setters.  From now on this class provides readonly
+  methods.  Use the win32-file package for attribute setters.
+* Added the content_indexed? alias for the indexed? method.
+* Corresponding test suite changes.
+* Fixed the pp issue by writing a custom pretty_print method.
+
+== 1.1.0 - 15-Apr-2006
+* Added the chardev?, dev_major, dev_minor directory?, file?, executable?,
+  executable_real?, ftype, grpowned?, owned?, pipe?, readable?, readable_real?,
+  rdev_major, rdev_minor, setgid?, setuid?, size?, socket?, sticky?, symlink?,
+  writable?, writable_real? and zero? methods.  Note that not all of these
+  methods return meaningful values and were merely added to match the current
+  spec.  See documentation for details.
+* Added a VERSION constant.
+* Some optimization in the constructor.
+
+== 1.0.0 - 13-Apr-2006
+* Initial release

data/MANIFEST

@@ -0,0 +1,11 @@
+CHANGES
+README
+MANIFEST
+install.rb
+win32-file-stat.gemspec
+
+lib/win32/file/stat.rb
+
+test/sometestfile.exe
+test/sometestfile.txt
+test/tc_file_stat.rb

data/README

@@ -0,0 +1,64 @@
+= Description
+A redefinition of the File::Stat class for MS Windows.
+
+= Prerequisites
+Ruby 1.8.0 or later.
+windows-pr 0.4.0 or later.
+
+= Installation, pure Ruby
+== Manual Installation
+ruby test/tc_file_stat.rb (optional)
+ruby install.rb
+   
+== Gem Installation
+=== Local
+ruby test/tc_file_stat.rb (Unix, optional)
+gem install win32-file-stat-<version>.gem
+=== Remote
+gem install win32-file-stat
+
+= Synopsis
+require 'win32/file/stat'
+
+stat = File::Stat.new('file.txt')
+stat.size
+stat.readonly?
+stat.hidden?
+
+= Differences between Ruby's File::Stat and this version:
+* The File::Stat#blksize method returns a meaningful value.
+* The File::Stat#blockdev method works more accurately.
+* The File::Stat#blocks method returns a meaningful value.
+* The File::Stat#dev method returns a drive letter, not a number.
+* The File::Stat#executable? method works properly.
+* The File::Stat#executable_real? returns the same value as
+  File::Stat#executable? (which now works properly).
+* The File::Stat#file? method works properly.
+* The File::Stat#ftype method works more accurately.
+* The File::Stat#pipe method works properly.
+* The File::Stat#size method handles file sizes greater than 2 gigabytes
+  correctly.
+* The File::Stat#socket method works more accurately.
+* Allows you to get file attributes specific to MS Windows, e.g. archive,
+  hidden, etc.
+* The pp (pretty print) output has been customized.
+  
+= Known issues or bugs
+None that I'm aware of. Please report any bugs you find on the project page
+at http://www.rubyforge.org/projects/win32utils.
+
+= Miscellaneous
+I had to require 'pp' explicitly in order to deal with the fact that pp.rb
+has a builtin pretty_print method for File::Stat.  If I didn't do this
+you would end up using the pretty_print in pp.rb, which would break.
+
+= License
+Ruby's
+
+= Warranty
+This package is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantability and fitness for a particular purpose.
+
+= Author
+Daniel J. Berger

data/install.rb

@@ -0,0 +1,12 @@
+require 'rbconfig'
+require 'ftools'
+include Config
+
+sitelibdir = CONFIG['sitelibdir']
+installdir = sitelibdir + '/win32/file'
+basedir = File.dirname(installdir)
+file = 'lib\win32\file\stat.rb'
+
+Dir.mkdir(basedir) unless File.exists?(basedir)
+Dir.mkdir(installdir) unless File.exists?(installdir)
+File.copy(file, installdir, true)

data/lib/win32/file/stat.rb

@@ -0,0 +1,552 @@
+require 'windows/msvcrt/buffer'
+require 'windows/msvcrt/file'
+require 'windows/filesystem'
+require 'windows/device_io'
+require 'windows/path'
+require 'windows/file'
+require 'windows/error'
+require 'windows/handle'
+require 'pp'
+
+class File::Stat
+   include Windows::MSVCRT::Buffer
+   include Windows::MSVCRT::File
+   include Windows::DeviceIO
+   include Windows::FileSystem
+   include Windows::Path
+   include Windows::File
+   include Windows::Error
+   include Windows::Handle
+   include Comparable
+   
+   VERSION = '1.2.3'
+
+   # Defined in Ruby's win32.h.  Not meant for public consumption.
+   S_IWGRP = 0020
+   S_IWOTH = 0002
+   
+   attr_reader :dev_major, :dev_minor, :rdev_major, :rdev_minor
+   
+   # Creates and returns a File::Stat object, which encapsulate common status
+   # information for File objects on MS Windows sytems. The information is
+   # recorded at the moment the File::Stat object is created; changes made to
+   # the file after that point will not be reflected.
+   #
+   def initialize(file)
+      @file = file
+      
+      @blockdev  = false
+      @file_type = get_file_type(file) # May update @blockdev
+      
+      @chardev = @file_type == FILE_TYPE_CHAR
+
+      stat_buf = [0,0,0,0,0,0,0,0,0,0,0,0,0].pack('ISSssssIIQQQQ')
+      
+      # The stat64 function doesn't seem to like character devices
+      if stat64(file, stat_buf) != 0
+          raise ArgumentError, get_last_error unless @chardev
+      end
+
+      # Some bytes skipped (padding for struct alignment)
+      @dev   = stat_buf[0, 4].unpack('I').first  # Drive number
+      @ino   = stat_buf[4, 2].unpack('S').first  # Meaningless
+      @mode  = stat_buf[6, 2].unpack('S').first  # File mode bit mask
+      @nlink = stat_buf[8, 2].unpack('s').first  # Always 1
+      @uid   = stat_buf[10, 2].unpack('s').first # Always 0
+      @gid   = stat_buf[12, 2].unpack('s').first # Always 0
+      @rdev  = stat_buf[16, 4].unpack('I').first # Same as dev
+      @size  = stat_buf[24, 8].unpack('Q').first # Size of file in bytes
+      @atime = Time.at(stat_buf[32, 8].unpack('Q').first) # Access time
+      @mtime = Time.at(stat_buf[40, 8].unpack('Q').first) # Modification time
+      @ctime = Time.at(stat_buf[48, 8].unpack('Q').first) # Creation time
+      
+      @mode = 33188 if @chardev
+
+      attr = GetFileAttributes(file)
+      
+      if attr == INVALID_FILE_ATTRIBUTES
+         raise ArgumentError, get_last_error
+      end
+      
+      @blksize = get_blksize(file)
+      
+      # This is a reasonable guess
+      case @blksize
+         when nil
+            @blocks = nil
+         when 0
+            @blocks = 0
+         else
+            @blocks  = (@size.to_f / @blksize.to_f).ceil
+      end
+      
+      @readonly      = attr & FILE_ATTRIBUTE_READONLY > 0
+      @hidden        = attr & FILE_ATTRIBUTE_HIDDEN > 0
+      @system        = attr & FILE_ATTRIBUTE_SYSTEM > 0
+      @archive       = attr & FILE_ATTRIBUTE_ARCHIVE > 0
+      @directory     = attr & FILE_ATTRIBUTE_DIRECTORY > 0
+      @encrypted     = attr & FILE_ATTRIBUTE_ENCRYPTED > 0
+      @normal        = attr & FILE_ATTRIBUTE_NORMAL > 0
+      @temporary     = attr & FILE_ATTRIBUTE_TEMPORARY > 0
+      @sparse        = attr & FILE_ATTRIBUTE_SPARSE_FILE > 0
+      @reparse_point = attr & FILE_ATTRIBUTE_REPARSE_POINT > 0
+      @compressed    = attr & FILE_ATTRIBUTE_COMPRESSED > 0
+      @offline       = attr & FILE_ATTRIBUTE_OFFLINE > 0
+      @indexed       = attr & ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED > 0
+      
+      @executable = GetBinaryType(file, '')
+      @regular    = @file_type == FILE_TYPE_DISK
+      @pipe       = @file_type == FILE_TYPE_PIPE
+      
+      # Not supported and/or meaningless
+      @dev_major     = nil
+      @dev_minor     = nil
+      @grpowned      = true
+      @owned         = true
+      @readable      = true
+      @readable_real = true
+      @rdev_major    = nil
+      @rdev_minor    = nil
+      @setgid        = false
+      @setuid        = false
+      @sticky        = false
+      @symlink       = false
+      @writable      = true
+      @writable_real = true
+   end
+   
+   ## Comparable
+   
+   # Compares two File::Stat objects.  Comparsion is based on mtime only.
+   #
+   def <=>(other)
+      @mtime.to_i <=> other.mtime.to_i
+   end
+   
+   ## Miscellaneous
+   
+   def blockdev?
+      @blockdev
+   end
+   
+   # Returns whether or not the file is a character device.
+   #
+   def chardev?
+      @chardev
+   end
+   
+   # Returns whether or not the file is executable.  Generally speaking, this
+   # means .bat, .cmd, .com, and .exe files.
+   #
+   def executable?
+      @executable
+   end
+   
+   alias :executable_real? :executable?
+   
+   # Returns whether or not the file is a regular file, as opposed to a pipe,
+   # socket, etc.
+   #
+   def file?
+      @regular
+   end
+   
+   # Identifies the type of file. The return string is one of: file,
+   # directory, characterSpecial, socket or unknown.
+   #
+   def ftype
+      return 'directory' if directory?
+      case @file_type
+         when FILE_TYPE_CHAR
+            'characterSpecial'
+         when FILE_TYPE_DISK
+            'file'
+         when FILE_TYPE_PIPE
+            'socket'
+         else
+            if blockdev?
+               'blockSpecial'
+            else
+               'unknown'
+            end
+      end
+   end
+   
+   # Meaningless on Windows.
+   #
+   def grpowned?
+      @grpowned
+   end
+   
+   # Always true on Windows
+   def owned?
+      @owned
+   end
+   
+   # Returns whether or not the file is a pipe.
+   #
+   def pipe?
+      @pipe
+   end
+   
+   alias :socket? :pipe?
+   
+   # Meaningless on Windows
+   #
+   def readable?
+      @readable
+   end
+   
+   # Meaningless on Windows
+   #
+   def readable_real?
+      @readable_real
+   end
+   
+   # Meaningless on Windows
+   #
+   def setgid?
+      @setgid
+   end
+   
+   # Meaningless on Windows
+   #
+   def setuid?
+      @setuid
+   end
+   
+   # Returns nil if statfile is a zero-length file; otherwise, returns the
+   # file size. Usable as a condition in tests.
+   #
+   def size?
+      @size > 0 ? @size : nil
+   end
+   
+   # Meaningless on Windows.
+   #
+   def sticky?
+      @sticky
+   end
+   
+   # Meaningless on Windows at the moment.  This may change in the future.
+   #
+   def symlink?
+      @symlink
+   end
+   
+   # Meaningless on Windows.
+   #
+   def writable?
+      @writable
+   end
+   
+   # Meaningless on Windows.
+   #
+   def writable_real?
+      @writable_real
+   end
+   
+   # Returns whether or not the file size is zero.
+   #
+   def zero?
+      @size == 0
+   end
+   
+   ## Attribute members
+   
+   # Returns whether or not the file is an archive file.
+   #
+   def archive?
+      @archive
+   end
+
+   # Returns whether or not the file is compressed.
+   #
+   def compressed?
+      @compressed
+   end
+   
+   # Returns whether or not the file is a directory.
+   #
+   def directory?
+      @directory
+   end
+   
+   # Returns whether or not the file in encrypted.
+   #
+   def encrypted?
+      @encrypted
+   end
+   
+   # Returns whether or not the file is hidden.
+   #
+   def hidden?
+      @hidden
+   end
+   
+   # Returns whether or not the file is content indexed.
+   #
+   def indexed?
+      @indexed
+   end
+   alias :content_indexed? :indexed?
+   
+   # Returns whether or not the file is 'normal'.  This is only true if
+   # virtually all other attributes are false.
+   #
+   def normal?
+      @normal
+   end
+   
+   # Returns whether or not the file is offline.
+   #
+   def offline?
+      @offline
+   end
+   
+   # Returns whether or not the file is readonly.
+   #
+   def readonly?
+      @readonly
+   end 
+
+   alias :read_only? :readonly?
+   
+   # Returns whether or not the file is a reparse point.
+   #
+   def reparse_point?
+      @reparse_point
+   end
+   
+   # Returns whether or not the file is a sparse file.  In most cases a sparse
+   # file is an image file.
+   #
+   def sparse?
+      @sparse
+   end
+   
+   # Returns whether or not the file is a system file.
+   #
+   def system?
+      @system
+   end
+   
+   # Returns whether or not the file is being used for temporary storage.
+   #
+   def temporary?
+      @temporary
+   end
+   
+   ## Standard stat members
+   
+   # Returns a Time object containing the last access time.
+   #
+   def atime
+      @atime
+   end
+   
+   # Returns the file system's block size, or nil if it cannot be determined.
+   #
+   def blksize
+      @blksize
+   end
+   
+   # Returns the number of blocks used by the file, where a block is defined
+   # as size divided by blksize, rounded up.
+   #
+   # :no-doc:
+   # This is a fudge.  A search of the internet reveals different ways people
+   # have defined st_blocks on MS Windows.
+   #
+   def blocks
+      @blocks
+   end
+   
+   # Returns a Time object containing the time that the file status associated
+   # with the file was changed.
+   #
+   def ctime
+      @ctime
+   end
+   
+   # Drive letter (A-Z) of the disk containing the file.  If the path is a
+   # UNC path then the drive number (probably -1) is returned instead.
+   #
+   def dev
+      if PathIsUNC(@file)
+         @dev
+      else
+         (@dev + ?A).chr + ':'
+      end
+   end
+   
+   # Group ID. Always 0.
+   #
+   def gid
+      @gid
+   end
+   
+   # Inode number. Meaningless on NTFS.
+   #
+   def ino
+      @ino
+   end
+   
+   # Bit mask for file-mode information.
+   #
+   # :no-doc:
+   # This was taken from rb_win32_stat() in win32.c.  I'm not entirely
+   # sure what the point is.
+   #
+   def mode
+      @mode &= ~(S_IWGRP | S_IWOTH)
+   end
+   
+   # Returns a Time object containing the modification time.
+   #
+   def mtime
+      @mtime
+   end
+
+   # Drive number of the disk containing the file.
+   #
+   def rdev
+      @rdev
+   end
+   
+   # Always 1
+   #
+   def nlink
+      @nlink
+   end
+   
+   # Returns the size of the file, in bytes.
+   #
+   def size
+      @size
+   end
+   
+   # User ID. Always 0.
+   #
+   def uid
+      @uid
+   end
+   
+   # Returns a stringified version of a File::Stat object.
+   #
+   def inspect    
+      members = %w/
+         archive? atime blksize blocks compressed? ctime dev encrypted? gid
+         hidden? indexed? ino mode mtime rdev nlink normal? offline? readonly?
+         reparse_point? size sparse? system? temporary? uid
+      /
+      str = "#<#{self.class}"
+      members.sort.each{ |mem|
+         if mem == 'mode'
+            str << " #{mem}=" << sprintf("0%o", send(mem.intern))
+         elsif mem[-1].chr == '?'
+            str << " #{mem.chop}=" << send(mem.intern).to_s
+         else
+            str << " #{mem}=" << send(mem.intern).to_s
+         end
+      }
+      str
+   end
+   
+   # A custom pretty print method.  This was necessary not only to handle
+   # the additional attributes, but to work around an error caused by the
+   # builtin method for the current File::Stat class (see pp.rb).
+   #
+   def pretty_print(q)
+      members = %w/
+         archive? atime blksize blocks compressed? ctime dev encrypted? gid
+         hidden? indexed? ino mode mtime rdev nlink normal? offline? readonly?
+         reparse_point? size sparse? system? temporary? uid
+      /
+
+      q.object_group(self){
+         q.breakable
+         members.each{ |mem|
+            q.group{
+               q.text("#{mem}".ljust(15) + "=> ")
+               if mem == 'mode'
+                  q.text(sprintf("0%o", send(mem.intern)))
+               else
+                  val = self.send(mem.intern)
+                  if val.nil?
+                     q.text('nil')
+                  else
+                     q.text(val.to_s)
+                  end
+               end
+            }
+            q.comma_breakable unless mem == members.last
+         }
+      }
+   end
+   
+   private
+   
+   # Returns the file system's block size.
+   #
+   def get_blksize(file)
+      size = nil
+   
+      sectors = [0].pack('L')
+      bytes   = [0].pack('L')
+      free    = [0].pack('L')
+      total   = [0].pack('L')
+      
+      # If there's a drive letter it must contain a trailing backslash.
+      # The dup is necessary here because, for some odd reason, the function
+      # appears to modify the argument passed in.
+      if PathStripToRoot(file.dup)
+         file += "\\" unless file[-1].chr == "\\"
+      else
+         file = 0 # Default to root drive
+      end
+      
+      # Don't check for an error here.  Just default to nil.
+      if GetDiskFreeSpace(file, sectors, bytes, free, total)
+         size = sectors.unpack('L').first * bytes.unpack('L').first
+      end
+      
+      size
+   end
+   
+   # Returns the file's type (as a numeric).
+   #
+   def get_file_type(file)
+      handle = CreateFile(
+         file,
+         0,
+         0,
+         0,
+         OPEN_EXISTING,
+         FILE_FLAG_BACKUP_SEMANTICS, # Need this for directories
+         0
+      )
+      
+      if handle == INVALID_HANDLE_VALUE
+         raise ArgumentError, get_last_error
+      end
+      
+      file_type = GetFileType(handle)
+      error = GetLastError()
+           
+      CloseHandle(handle)
+      
+      if error == 0
+         if file_type == FILE_TYPE_DISK || file_type == FILE_TYPE_UNKNOWN
+            @blockdev = true
+         end
+      end
+      
+      file_type
+   end
+   
+   # Verifies that a value is either true or false
+   def check_bool(val)
+      raise TypeError unless val == true || val == false
+   end
+end

data/test/sometestfile.exe

@@ -0,0 +1 @@
+This is a test

data/test/sometestfile.txt

@@ -0,0 +1 @@
+This is a test

data/test/tc_file_stat.rb

@@ -0,0 +1,312 @@
+#####################################################################
+# tc_file_stat.rb
+#
+# Test case for stat related methods of win32-file.
+#####################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /win32-file-stat/
+	Dir.chdir('..') if base == 'test'
+	$LOAD_PATH.unshift(Dir.pwd + '/lib')
+	Dir.chdir('test') rescue nil
+end
+
+require 'test/unit'
+require 'win32/file/stat'
+
+class TC_Win32_File_Stat < Test::Unit::TestCase
+   include Windows::File  
+   def setup
+      @file   = 'sometestfile.txt'
+      @exe    = 'sometestfile.exe'
+      @dir    = Dir.pwd 
+      @stat   = File::Stat.new(@file)
+   end
+   
+   def test_version
+      assert_equal('1.2.3', File::Stat::VERSION)
+   end
+   
+   # One or more tests will fail if the archive attribute on @file is not set.
+   def test_archive
+      assert_respond_to(@stat, :archive?)
+      assert_nothing_raised{ @stat.archive? }
+      assert(@stat.archive?)
+   end
+   
+   def test_atime
+      assert_respond_to(@stat, :atime)
+      assert_kind_of(Time, @stat.atime)
+   end
+   
+   def test_blksize
+      assert_respond_to(@stat, :blksize)
+      assert_equal(4096, @stat.blksize)
+   end
+   
+   def test_blockdev
+      assert_respond_to(@stat, :blockdev?)
+      assert_equal(true, @stat.blockdev?)
+      assert_equal(false, File::Stat.new('NUL').blockdev?)
+   end
+   
+   def test_blocks
+      assert_respond_to(@stat, :blocks)
+      assert_equal(1, @stat.blocks)
+   end
+   
+   def test_chardev
+      assert_respond_to(@stat, :chardev?)
+      assert_nothing_raised{ File::Stat.new("NUL").chardev? }     
+      assert_equal(true, File::Stat.new("NUL").chardev?)
+      assert_equal(false, File::Stat.new("C:\\").chardev?)
+   end
+   
+   def test_comparison
+      assert_respond_to(@stat, :<=>)
+      assert_nothing_raised{ @stat <=> File::Stat.new(@exe) }
+   end
+   
+   def test_compressed
+      assert_respond_to(@stat, :compressed?)
+      assert_nothing_raised{ @stat.compressed? }
+      assert_equal(false, @stat.compressed?)
+   end
+   
+   def test_ctime
+      assert_respond_to(@stat, :ctime)
+      assert_kind_of(Time, @stat.ctime)
+   end
+   
+   # Assumes you've installed on C: drive.
+   def test_dev
+      assert_respond_to(@stat, :dev)
+      assert_equal('C:', @stat.dev)
+   end
+   
+   def test_dev_major
+      assert_respond_to(@stat, :dev_major)
+      assert_nil(@stat.dev_major)
+   end
+   
+   def test_dev_minor
+      assert_respond_to(@stat, :dev_minor)
+      assert_nil(@stat.dev_minor)
+   end
+   
+   def test_directory
+      assert_respond_to(@stat, :directory?)
+      assert_equal(false, @stat.directory?)
+      assert_equal(true, File::Stat.new("C:\\").directory?)
+   end
+   
+   def test_executable
+      assert_respond_to(@stat, :executable?)
+      assert_equal(false, @stat.executable?)
+      assert_equal(true, File::Stat.new(@exe).executable?)
+   end
+   
+   def test_executable_real
+      assert_respond_to(@stat, :executable_real?)
+      assert_equal(false, @stat.executable_real?)
+      assert_equal(true, File::Stat.new(@exe).executable_real?)
+   end
+   
+   def test_file
+      assert_respond_to(@stat, :file?)
+      assert_equal(true, @stat.file?)
+      assert_equal(true, File::Stat.new(@exe).file?)
+      assert_equal(true, File::Stat.new(Dir.pwd).file?)
+      assert_equal(false, File::Stat.new('NUL').file?)
+   end
+   
+   def test_ftype
+      assert_respond_to(@stat, :ftype)
+      assert_equal('file', @stat.ftype)
+      assert_equal('characterSpecial', File::Stat.new('NUL').ftype)
+      assert_equal('directory', File::Stat.new(Dir.pwd).ftype)
+   end
+   
+   def encrypted
+      assert_respond_to(@stat, :encrypted?)
+      assert_nothing_raised{ @stat.encrypted? }
+   end
+   
+   def test_gid
+      assert_respond_to(@stat, :gid)
+      assert_equal(0, @stat.gid)
+   end
+   
+   def test_grpowned
+      assert_respond_to(@stat, :grpowned?)
+   end
+   
+   def test_hidden
+      assert_respond_to(@stat, :hidden?)
+      assert_nothing_raised{ @stat.hidden? }
+      assert_equal(false, @stat.hidden?)
+   end
+   
+   def test_indexed
+      assert_respond_to(@stat, :indexed?)
+      assert_respond_to(@stat, :content_indexed?) # alias
+      assert_nothing_raised{ @stat.indexed? }
+      assert(@stat.indexed?)
+   end
+   
+   def test_ino
+      assert_respond_to(@stat, :ino)
+      assert_equal(0, @stat.ino)
+   end
+   
+   def test_inspect
+      assert_respond_to(@stat, :inspect)
+   end
+   
+   def test_mode
+      assert_respond_to(@stat, :mode)
+      assert_equal(33188, File::Stat.new(@file).mode)
+      assert_equal(33261, File::Stat.new(@exe).mode)
+      assert_equal(16877, File::Stat.new(@dir).mode)
+      
+      SetFileAttributes(@file, 1) # Set to readonly.
+      assert_equal(33060, File::Stat.new(@file).mode)
+   end
+   
+   def test_mtime
+      assert_respond_to(@stat, :mtime)
+      assert_kind_of(Time, @stat.mtime)
+   end
+   
+   def test_nlink
+      assert_respond_to(@stat, :nlink)
+      assert_equal(1, @stat.nlink)
+   end
+   
+   def test_normal
+      assert_respond_to(@stat, :normal?)
+      assert_nothing_raised{ @stat.normal? }
+      assert(@stat.normal?)
+   end
+   
+   def test_offline
+      assert_respond_to(@stat, :offline?)
+      assert_nothing_raised{ @stat.offline? }
+      assert_equal(false, @stat.offline?)
+   end
+   
+   def test_pipe
+      assert_respond_to(@stat, :pipe?)
+      assert_equal(false, @stat.pipe?)
+   end
+   
+   def test_readable
+      assert_respond_to(@stat, :readable?)
+      assert_equal(true, @stat.readable?)
+   end
+   
+   def test_readable_real
+      assert_respond_to(@stat, :readable_real?)
+      assert_equal(true, @stat.readable_real?)
+   end
+   
+   def test_readonly
+      assert_respond_to(@stat, :readonly?)
+      assert_nothing_raised{ @stat.readonly? }
+      assert_equal(false, @stat.readonly?)
+   end
+   
+   def test_reparse_point
+      assert_respond_to(@stat, :reparse_point?)
+      assert_nothing_raised{ @stat.reparse_point? }
+      assert_equal(false, @stat.reparse_point?)
+   end 
+   
+   # Assumes you've installed on C: drive.
+   def test_rdev
+      msg = "ignore failure if Ruby is not installed on C: drive"
+      assert_respond_to(@stat, :rdev)
+      assert_equal(2, @stat.rdev, msg)
+   end
+   
+   def test_setgid
+      assert_respond_to(@stat, :setgid?)
+      assert_equal(false, @stat.setgid?)
+   end
+   
+   def test_setuid
+      assert_respond_to(@stat, :setuid?)
+      assert_equal(false, @stat.setuid?)
+   end
+
+   def test_size
+      assert_respond_to(@stat, :size)
+      assert_equal(16, @stat.size)
+   end
+   
+   def test_size_bool
+      assert_respond_to(@stat, :size?)
+      assert_equal(16, @stat.size?)
+   end
+   
+   def test_socket
+      assert_respond_to(@stat, :socket?)
+      assert_equal(false, @stat.socket?)
+   end
+   
+   def test_sparse
+      assert_respond_to(@stat, :sparse?)
+      assert_nothing_raised{ @stat.sparse? }
+      assert_equal(false, @stat.sparse?)
+   end
+   
+   def test_sticky
+      assert_respond_to(@stat, :sticky?)
+      assert_equal(false, @stat.sticky?)
+   end
+   
+   def test_symlink
+      assert_respond_to(@stat, :symlink?)
+      assert_equal(false, @stat.symlink?)
+   end
+   
+   def test_system
+      assert_respond_to(@stat, :system?)
+      assert_nothing_raised{ @stat.system? }
+      assert_equal(false, @stat.system?)
+   end
+   
+   def test_temporary
+      assert_respond_to(@stat, :temporary?)
+      assert_nothing_raised{ @stat.temporary? }
+      assert_equal(false, @stat.temporary?)
+   end  
+   
+   def test_uid
+      assert_respond_to(@stat, :uid)
+      assert_equal(0, @stat.uid)
+   end
+   
+   def test_writable
+      assert_respond_to(@stat, :writable?)
+      assert_equal(true, @stat.writable?)
+   end
+   
+   def test_writable_real
+      assert_respond_to(@stat, :writable_real?)
+      assert_equal(true, @stat.writable_real?)
+   end
+   
+   def test_zero
+      assert_respond_to(@stat, :zero?)
+      assert_equal(false, @stat.zero?)
+   end
+
+   def teardown
+      SetFileAttributes(@file, 8) # Set file back to normal
+      @file = nil
+      @exe  = nil
+      @dir  = nil
+      @stat = nil     
+   end
+end

data/win32-file-stat.gemspec

@@ -0,0 +1,24 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |gem|
+   gem.name        = "win32-file-stat"
+   gem.version     = "1.2.3"
+   gem.author      = "Daniel J. Berger"
+   gem.email       = "djberg96@gmail.com"
+   gem.homepage    = "http://www.rubyforge.org/projects/win32utils"
+   gem.platform    = Gem::Platform::RUBY
+   gem.summary     = "A File::Stat class tailored to MS Windows"
+   gem.description = "A File::Stat class tailored to MS Windows"
+   gem.test_file   = "test/tc_file_stat.rb"
+   gem.has_rdoc    = true
+   gem.files = Dir['lib/win32/file/*.rb'] + Dir['[A-Z]*']  + Dir['test/*']
+   gem.files.reject! { |fn| fn.include? "CVS" }
+   gem.require_path = "lib"
+   gem.extra_rdoc_files = ["README", "CHANGES"]
+   gem.add_dependency("windows-pr", ">= 0.4.0")
+end
+
+if $0 == __FILE__
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: win32-file-stat
+version: !ruby/object:Gem::Version 
+  version: 1.2.3
+date: 2006-11-04 00:00:00 -07:00
+summary: A File::Stat class tailored to MS Windows
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/win32utils
+rubyforge_project: 
+description: A File::Stat class tailored to MS Windows
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- lib/win32/file/stat.rb
+- CHANGES
+- install.rb
+- lib
+- MANIFEST
+- README
+- test
+- win32-file-stat.gemspec
+- test/sometestfile.exe
+- test/sometestfile.txt
+- test/tc_file_stat.rb
+test_files: 
+- test/tc_file_stat.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: windows-pr
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: