sys-filesystem 0.3.2-x86-mingw32

data/CHANGES

@@ -0,0 +1,35 @@
+== 0.3.2 - 29-Dec-2009
+* Source has been moved to github.
+* Added the 'gem' task and removed build logic from the gemspec.
+* Updated the install task.
+* Minor correction to the manifest.
+* Removed some junk build files that were inadvertently included in
+  the last gem.
+
+== 0.3.1 - 5-Aug-2009
+* Now compatible with Ruby 1.9.x.
+* Changed license to Artistic 2.0
+* Updated the gemspec, including the explicit addition of a license and
+  test-unit as a development dependency, as well as an updated description. 
+
+== 0.3.0 - 26-Feb-2009
+* Added support for OS X and FreeBSD thanks to an awesome patch by Nobuyoshi
+  Miyokawa.
+* Added the Filesystem.mount_point method that takes a file and returns
+  the mount point it's sitting on.
+
+== 0.2.0 - 30-Dec-2008
+* Added the Filesystem.mounts method for iterating over mount or volume
+  information.
+
+== 0.1.1 - 28-Mar-2007
+* Bug fix for BSD flavors.  Thanks go to Jeremy Kemper and Ole Christian
+  Rynning for the spot.
+* Bug fix for OS X (along the same lines as the BSD fix). Thanks go to
+  Aurelian Dehay for the spot.
+* Some Rdoc improvements for the C extension.
+* Tweaks to the gemspec.
+* Added synopsis to the README.
+
+== 0.1.0 - 17-Nov-2006
+* Initial release.  Alpha. Code is stable, but API is not.

data/MANIFEST

@@ -0,0 +1,13 @@
+* MANIFEST
+* CHANGES
+* Rakefile
+* README
+* sys-fileystem.gemspec
+* examples/example_stat.rb
+* doc/sys-filesystem.txt
+* ext/extconf.rb
+* ext/sys/filesystem.c
+* lib/sys/filesystem.rb
+* test/test_sys_filesystem.rb
+* test/test_sys_filesystem_unix
+* test/test_sys_filesystem_windows

data/README

@@ -0,0 +1,82 @@
+= Description
+   A Ruby interface for getting file system information.
+
+= Prerequisites
+=== MS Windows 
+* windows-pr, 0.9.8 or later.
+
+= Installation
+   rake test (optional)
+   rake install (non-gem) OR rake install_gem (gem)
+
+= Synopsis
+   require 'sys/filesystem'
+   include Sys
+   
+   # Display information about a particular filesystem.
+   p Filesystem.stat('/')
+
+   # Sample output
+
+   #<Sys::Filesystem::Stat:0x517440
+      @base_type = "ufs",
+      @flags = 4,
+      @files_available = 3817457,
+      @block_size = 8192,
+      @blocks_available = 19957633,
+      @blocks = 34349612,
+      @name_max = 255,
+      @path = "/",
+      @filesystem_id = 35651592,
+      @files = 4135040,
+      @fragment_size = 1024,
+      @files_free = 3817457,
+      @blocks_free = 20301129
+   >
+   
+   # Describe all mount points on the system
+   Filesystem.mounts{ |mount| p mount }
+   
+   # Find the mount point of any particular file
+   puts Filesystem.mount_point('/home/djberge/some_file.txt') => '/home'
+
+= Notes
+=== MS Windows
+   This is a pure Ruby implementation using the windows-pr library, which in
+   turn wraps native Windows functions.
+=== UNIX
+   This is a C extension that wraps statvfs, etc.
+
+= Sample code
+   Run 'rake example' if you want to see a basic sample run. The actual code
+   is 'example_stat.rb' in the 'examples' directory. Modify it as you see fit.
+
+= Known Bugs
+   None that I'm aware of.  Please report bugs on the project page at
+   http://www.rubyforge.org/projects/sysutils.
+
+= Future Plans
+   Suggestions welcome.
+
+= Acknowledgements
+   Mike Hall, for ideas and code that I borrowed from his 'filesystem'
+   library.
+   
+   Park Heesob, for implementation and API ideas for the MS Windows version.
+   
+   Nobuyoshi Miyokawa, for adding FreeBSD and OS X support.
+   
+= License
+   Artistic 2.0
+
+= Copyright
+   (C) 2003-2009 Daniel J. Berger
+   All Rights Reserved
+
+= Warranty
+   This library 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/Rakefile

@@ -0,0 +1,95 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+include Config
+
+desc "Clean the build files for the sys-filesystem source for UNIX systems"
+task :clean do |task|
+  Dir.chdir('examples') do
+    FileUtils.rm_rf('sys') if File.exists?('sys')
+  end
+
+  unless Config::CONFIG['host_os'] =~ /mswin32|mingw|cygwin|windows|dos/i
+    file = 'sys/filesystem.' + CONFIG['DLEXT']
+    Dir.chdir('ext') do
+      sh 'make distclean' rescue nil
+      rm file if File.exists?(file)
+      rm_rf 'conftest.dSYM' if File.exists?('conftest.dSYM') # OS X weirdness
+    end
+  end
+end
+
+desc "Build the sys-filesystem library on UNIX systems (but don't install it)"
+task :build => [:clean] do
+  unless Config::CONFIG['host_os'] =~ /mswin32|mingw|cygwin|windows|dos/i
+    file = 'filesystem.' + CONFIG['DLEXT']
+    Dir.chdir('ext') do
+      ruby 'extconf.rb'
+      sh 'make'
+      mv file, 'sys'
+    end
+  end
+end
+
+desc "Install the sys-filesystem library"
+task :install do
+  unless Config::CONFIG['host_os'] =~ /mswin32|mingw|cygwin|windows|dos/i
+    install_dir = File.join(CONFIG['sitelibdir'], 'sys')
+    Dir.mkdir(install_dir) unless File.exists?(install_dir)
+    FileUtils.cp('lib/sys/filesystem.rb', install_dir, :verbose => true)
+  else
+    task :install => :build
+    Dir.chdir('ext') do
+      sh 'make install'
+    end
+  end
+end
+
+desc "Run the test suite"
+Rake::TestTask.new("test") do |t|
+  unless Config::CONFIG['host_os'] =~ /mswin32|mingw|cygwin|windows|dos/i
+    task :test => :build
+    t.libs << 'ext'
+    t.libs.delete('lib')
+  end
+
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_sys_filesystem.rb']
+end
+
+task :test do
+  Rake.application[:clean].execute
+end
+
+desc "Run the example program"
+task :example => [:build] do |t|
+  Dir.chdir('examples') do
+    Dir.mkdir('sys') unless File.exists?('sys')
+  end
+
+  FileUtils.cp('ext/sys/filesystem.' + Config::CONFIG['DLEXT'], 'examples/sys')
+
+  Dir.chdir('examples') do
+    ruby 'example_stat.rb'
+  end
+end
+
+desc "Build a gem"
+task :gem => [:clean] do |t|
+  spec = eval(IO.read('sys-filesystem.gemspec'))
+
+  if Config::CONFIG['host_os'] =~ /mswin32|mingw|cygwin|windows|dos/i
+    spec.required_ruby_version = '>= 1.8.2'
+    spec.files -= Dir['ext/**/*']
+    spec.platform = Gem::Platform::CURRENT
+    spec.add_dependency('windows-pr', '>= 1.0.5')
+  else
+    spec.required_ruby_version = '>= 1.8.0'
+    spec.extensions = ['ext/extconf.rb']
+    spec.files -= Dir['lib/**/*']
+    spec.extra_rdoc_files << 'ext/sys/filesystem.c'
+  end
+
+  Gem::Builder.new(spec).build
+end

data/examples/example_stat.rb

@@ -0,0 +1,24 @@
+######################################################################
+# example_stat.rb
+#
+# Example program that demonstrates the FileSystem.stat method.
+# Use the 'rake example' task to run this program.
+######################################################################
+require 'sys/filesystem'
+include Sys
+
+p Filesystem::VERSION
+
+stat = Filesystem.stat("/")
+puts "Path: " + stat.path
+puts "Block size: " + stat.block_size.to_s
+puts "Fragment size: " + stat.fragment_size.to_s
+puts "Blocks free: " + stat.blocks_free.to_s
+puts "Blocks available: " + stat.blocks_available.to_s
+puts "Files/Inodes: " + stat.files.to_s
+puts "Files/Inodes free: " + stat.files_free.to_s
+puts "Files/Inodes available: " + stat.files_available.to_s
+puts "File system id: " + stat.filesystem_id.to_s
+puts "Base type: " + stat.base_type if stat.base_type
+puts "Flags: " + stat.flags.to_s
+puts "Name max: " + stat.name_max.to_s

data/lib/sys/filesystem.rb

@@ -0,0 +1,408 @@
+require 'windows/error'
+require 'windows/path'
+require 'windows/filesystem'
+require 'windows/volume'
+require 'windows/handle'
+require 'windows/limits'
+require 'socket'
+require 'win32ole'
+require 'date'
+require 'time'
+
+# The Sys module serves as a namespace only.
+module Sys
+
+   # The Filesystem class encapsulates information about your filesystem.
+   class Filesystem
+      include Windows::Error
+      include Windows::Handle
+      include Windows::Limits
+
+      extend Windows::Error
+      extend Windows::FileSystem
+      extend Windows::Volume
+      extend Windows::Path
+
+      # Error typically raised if any of the Sys::Filesystem methods fail.
+      class Error < StandardError; end
+
+      CASE_SENSITIVE_SEARCH      = 0x00000001  
+      CASE_PRESERVED_NAMES       = 0x00000002  
+      UNICODE_ON_DISK            = 0x00000004  
+      PERSISTENT_ACLS            = 0x00000008  
+      FILE_COMPRESSION           = 0x00000010  
+      VOLUME_QUOTAS              = 0x00000020  
+      SUPPORTS_SPARSE_FILES      = 0x00000040  
+      SUPPORTS_REPARSE_POINTS    = 0x00000080  
+      SUPPORTS_REMOTE_STORAGE    = 0x00000100  
+      VOLUME_IS_COMPRESSED       = 0x00008000  
+      SUPPORTS_OBJECT_IDS        = 0x00010000  
+      SUPPORTS_ENCRYPTION        = 0x00020000  
+      NAMED_STREAMS              = 0x00040000  
+      READ_ONLY_VOLUME           = 0x00080000
+      
+      # The version of the sys-filesystem library.
+      VERSION = '0.3.2'
+
+      class Mount
+         # The name of the volume. This is the device mapping.
+         attr_reader :name
+
+         # The last time the volume was mounted. For MS Windows this equates
+         # to your system's boot time.
+         attr_reader :mount_time
+
+         # The type of mount, e.g. NTFS, UDF, etc.
+         attr_reader :mount_type
+
+         # The volume mount point, e.g. 'C:\'
+         attr_reader :mount_point
+
+         # Various comma separated options that reflect the volume's features
+         attr_reader :options
+
+         # Always nil on MS Windows. Provided for interface compatibility only.
+         attr_reader :pass_number
+
+         # Always nil on MS Windows. Provided for interface compatibility only.
+         attr_reader :frequency
+         
+         alias fsname name
+         alias dir mount_point
+         alias opts options
+         alias passno pass_number
+         alias freq frequency
+      end
+
+      class Stat
+         # The path of the file system.
+         attr_reader :path
+
+         # The file system block size.  MS Windows typically defaults to 4096.
+         attr_reader :block_size
+
+         # Fragment size. Meaningless at the moment.
+         attr_reader :fragment_size
+
+         # The total number of blocks available (used or unused) on the file
+         # system.
+         attr_reader :blocks
+
+         # The total number of unused blocks.
+         attr_reader :blocks_free
+
+         # The total number of unused blocks available to unprivileged
+         # processes. Identical to +blocks+ at the moment.
+         attr_reader :blocks_available
+
+         # Total number of files/inodes that can be created on the file system.
+         # This attribute is always nil on MS Windows.
+         attr_reader :files
+
+         # Total number of free files/inodes that can be created on the file
+         # system.  This attribute is always nil on MS Windows.
+         attr_reader :files_free
+
+         # Total number of available files/inodes for unprivileged processes
+         # that can be created on the file system. This attribute is always
+         # nil on MS Windows.
+         attr_reader :files_available
+
+         # The file system volume id.
+         attr_reader :filesystem_id
+
+         # A bit mask of file system flags.
+         attr_reader :flags
+
+         # The maximum length of a file name permitted on the file system.
+         attr_reader :name_max
+
+         # The file system type, e.g. NTFS, FAT, etc.
+         attr_reader :base_type
+
+         alias inodes files
+         alias inodes_free files_free
+         alias inodes_available files_available
+      end
+
+      # Yields a Filesystem::Mount object for each volume on your system in
+      # block form. Returns an array of Filesystem::Mount objects in non-block
+      # form.
+      #
+      # Example:
+      #
+      #    Sys::Filesystem.mounts{ |mount|
+      #       p mt.name        # => \\Device\\HarddiskVolume1
+      #       p mt.mount_point # => C:\
+      #       p mt.mount_time  # => Thu Dec 18 20:12:08 -0700 2008
+      #       p mt.mount_type  # => NTFS
+      #       p mt.options     # => casepres,casesens,ro,unicode 
+      #       p mt.pass_number # => nil
+      #       p mt.dump_freq   # => nil
+      #    }
+      #
+      # This method is a bit of a fudge for MS Windows in the name of interface
+      # compatibility because this method deals with volumes, not actual mount
+      # points. But, I believe it provides the sort of information many users
+      # want at a glance.
+      #
+      # The possible values for the +options+ and their meanings are as follows:
+      #
+      # casepres     => The filesystem preserves the case of file names when it places a name on disk.
+      # casesens     => The filesystem supports case-sensitive file names.
+      # compression  => The filesystem supports file-based compression.
+      # namedstreams => The filesystem supports named streams.
+      # pacls        => The filesystem preserves and enforces access control lists.
+      # ro           => The filesystem is read-only.
+      # encryption   => The filesystem supports the Encrypted File System (EFS).
+      # objids       => The filesystem supports object identifiers.
+      # rpoints      => The filesystem supports reparse points.
+      # sparse       => The filesystem supports sparse files.
+      # unicode      => The filesystem supports Unicode in file names as they appear on disk.
+      # compressed   => The filesystem is compressed.
+      #
+      def self.mounts
+         buffer = 0.chr * MAXPATH
+         length = GetLogicalDriveStrings(buffer.size, buffer)
+
+         if length == 0
+            raise Error, get_last_error
+         end
+
+         mounts = block_given? ? nil : []
+
+         # Try again if it fails
+         if length > buffer.size
+            buffer = 0.chr * length
+            if GetLogicalDriveStrings(buffer.size, buffer) == 0
+               raise Error, get_last_error
+            end
+         end
+
+         boot_time = get_boot_time
+
+         drives = buffer.strip.split("\0")
+
+         drives.each{ |drive|
+            mount  = Mount.new
+            volume = 0.chr * MAXPATH
+            fsname = 0.chr * MAXPATH
+
+            mount.instance_variable_set(:@mount_point, drive)
+            mount.instance_variable_set(:@mount_time, boot_time)
+
+            volume_serial_number = [0].pack('L')
+            max_component_length = [0].pack('L')
+            filesystem_flags     = [0].pack('L')
+
+            bool = GetVolumeInformation(
+               drive,
+               volume,
+               volume.size,
+               volume_serial_number,
+               max_component_length,
+               filesystem_flags,
+               fsname,
+               fsname.size
+            )
+
+            # Skip unmounted floppies or cd-roms
+            unless bool
+               errnum = GetLastError()
+               if errnum == ERROR_NOT_READY
+                  next
+               else
+                  raise Error, get_last_error(errnum)
+               end
+            end
+
+            filesystem_flags = filesystem_flags.unpack('L')[0]
+
+            name = 0.chr * MAXPATH
+
+            if QueryDosDevice(drive[0,2], name, name.size) == 0
+               raise Error, get_last_error
+            end
+
+            mount.instance_variable_set(:@name, name.strip)
+            mount.instance_variable_set(:@mount_type, fsname.strip)
+            mount.instance_variable_set(:@options, get_options(filesystem_flags))
+
+            if block_given?
+               yield mount
+            else
+               mounts << mount
+            end
+         }
+
+         mounts # Nil if the block form was used.
+      end
+
+      # Returns the mount point for the given +file+. For MS Windows this
+      # means the root of the path.
+      #
+      # Example:
+      #
+      #    File.mount_point("C:\\Documents and Settings") # => "C:\\'
+      #
+      def self.mount_point(file)
+         file = file.tr(File::SEPARATOR, File::ALT_SEPARATOR)
+         PathStripToRoot(file)
+         file[/^[^\0]*/]
+      end
+
+      # Returns a Filesystem::Stat object that contains information about the
+      # +path+ file system.
+      #
+      # Examples:
+      #
+      #    File.stat("C:\\")
+      #    File.stat("C:\\Documents and Settings\\some_user")
+      #
+      def self.stat(path)
+         bytes_avail = [0].pack('Q')
+         bytes_free  = [0].pack('Q')
+         total_bytes = [0].pack('Q')
+
+         unless GetDiskFreeSpaceEx(path, bytes_avail, total_bytes, bytes_free)
+            raise Error, get_last_error 
+         end                           
+
+         bytes_avail = bytes_avail.unpack('Q').first
+         bytes_free  = bytes_free.unpack('Q').first
+         total_bytes = total_bytes.unpack('Q').first
+
+         sectors = [0].pack('Q')
+         bytes   = [0].pack('Q')
+         free    = [0].pack('Q')
+         total   = [0].pack('Q')
+
+         unless GetDiskFreeSpace(path, sectors, bytes, free, total)
+            raise Error, get_last_error
+         end
+
+         sectors = sectors.unpack('Q').first
+         bytes   = bytes.unpack('Q').first
+         free    = free.unpack('Q').first
+         total   = total.unpack('Q').first
+
+         block_size   = sectors * bytes
+         blocks_avail = total_bytes / block_size
+         blocks_free  = bytes_free / block_size
+
+         vol_name   = 0.chr * 260
+         base_type  = 0.chr * 260
+         vol_serial = [0].pack('L')
+         name_max   = [0].pack('L')
+         flags      = [0].pack('L')
+
+         bool = GetVolumeInformation(
+            path,
+            vol_name,
+            vol_name.size,
+            vol_serial,
+            name_max,
+            flags,
+            base_type,
+            base_type.size
+         )
+
+         unless bool
+            raise Error, get_last_error
+         end
+
+         vol_serial = vol_serial.unpack('L').first
+         name_max   = name_max.unpack('L').first
+         flags      = flags.unpack('L').first
+         base_type  = base_type[/^[^\0]*/]
+
+         stat_obj = Stat.new
+         stat_obj.instance_variable_set(:@path, path)
+         stat_obj.instance_variable_set(:@block_size, block_size)
+         stat_obj.instance_variable_set(:@blocks, blocks_avail)
+         stat_obj.instance_variable_set(:@blocks_available, blocks_avail)
+         stat_obj.instance_variable_set(:@blocks_free, blocks_free)
+         stat_obj.instance_variable_set(:@name_max, name_max)
+         stat_obj.instance_variable_set(:@base_type, base_type)
+         stat_obj.instance_variable_set(:@flags, flags)
+         stat_obj.instance_variable_set(:@filesystem_id, vol_serial)
+   
+         stat_obj.freeze # Read-only object
+      end
+
+      private
+
+      # This method is used to get the boot time of the system, which is used
+      # for the mount_time attribute within the File.mounts method.
+      #
+      def self.get_boot_time
+         host = Socket.gethostname
+         cs = "winmgmts://#{host}/root/cimv2"
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            query = 'select LastBootupTime from Win32_OperatingSystem'
+            results = wmi.ExecQuery(query)
+            results.each{ |ole|
+               time_array = Time.parse(ole.LastBootupTime.split('.').first)
+               return Time.mktime(*time_array)
+            }
+         end
+      end
+
+      # Private method that converts filesystem flags into a comma separated
+      # list of strings. The presentation is meant as a rough analogue to the
+      # way options are presented for Unix filesystems.
+      #
+      def self.get_options(flags)
+         str = ""
+         str << " casepres" if CASE_PRESERVED_NAMES & flags > 0
+         str << " casesens" if CASE_SENSITIVE_SEARCH & flags > 0
+         str << " compression" if FILE_COMPRESSION & flags > 0
+         str << " namedstreams" if NAMED_STREAMS & flags > 0
+         str << " pacls" if PERSISTENT_ACLS & flags > 0
+         str << " ro" if READ_ONLY_VOLUME & flags > 0
+         str << " encryption" if SUPPORTS_ENCRYPTION & flags > 0
+         str << " objids" if SUPPORTS_OBJECT_IDS & flags > 0
+         str << " rpoints" if SUPPORTS_REPARSE_POINTS & flags > 0
+         str << " sparse" if SUPPORTS_SPARSE_FILES & flags > 0
+         str << " unicode" if UNICODE_ON_DISK & flags > 0
+         str << " compressed" if VOLUME_IS_COMPRESSED & flags > 0
+
+         str.tr!(' ', ',')
+         str = str[1..-1] # Ignore the first comma
+         str
+      end
+
+   end
+end
+
+# Some convenient methods for converting bytes to kb, mb, and gb.
+# 
+class Fixnum
+   # call-seq:
+   #  <tt>fix</tt>.to_kb
+   #
+   # Returns +fix+ in terms of kilobytes.
+   def to_kb
+      self / 1024
+   end
+   
+   # call-seq:
+   #  <tt>fix</tt>.to_mb
+   #
+   # Returns +fix+ in terms of megabytes.
+   def to_mb
+      self / 1048576
+   end
+   
+   # call-seq:
+   #  <tt>fix</tt>.to_gb
+   #
+   # Returns +fix+ in terms of gigabytes.
+   def to_gb
+      self / 1073741824
+   end
+end

data/sys-filesystem.gemspec

@@ -0,0 +1,25 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |gem|
+  gem.name      = 'sys-filesystem'
+  gem.version   = '0.3.2'
+  gem.author    = 'Daniel J. Berger'
+  gem.email     = 'djberg96@gmail.com'
+  gem.homepage  = 'http://www.rubyforge.org/projects/sysutils'
+  gem.platform  = Gem::Platform::RUBY
+  gem.summary   = 'A Ruby interface for getting file system information.'
+  gem.test_file = 'test/test_sys_filesystem.rb'
+  gem.has_rdoc  = true
+  gem.files     = Dir['**/*'].reject{ |f| f.include?('git') }
+  gem.license   = 'Artistic 2.0'
+   
+  gem.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
+  gem.rubyforge_project = 'sysutils'
+   
+  gem.add_development_dependency('test-unit', '>= 2.0.3')
+
+  gem.description = <<-EOF
+    The sys-filesystem library provides an interface for gathering filesystem
+    information, such as disk space and mount point data.
+  EOF
+end

data/test/test_sys_filesystem.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.dirname(File.expand_path(__FILE__))
+   
+require 'rbconfig'
+
+if Config::CONFIG['host_os'] =~ /mswin32|mingw|cygwin|windows|dos/i
+   require 'test_sys_filesystem_windows'
+else
+   require 'test_sys_filesystem_unix'
+end

data/test/test_sys_filesystem_unix.rb

@@ -0,0 +1,248 @@
+####################################################################
+# test_sys_filesystem_unix.rb
+#
+# Test case for the Sys::Filesystem.stat method and related stuff.
+# This test suite should be run via the 'rake test' task.
+####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'sys/filesystem'
+include Sys
+
+class TC_Sys_Filesystem_Unix < Test::Unit::TestCase
+  def self.startup
+    @@solaris = Config::CONFIG['host_os'] =~ /solaris/i
+    @@linux   = Config::CONFIG['host_os'] =~ /linux/i
+    @@freebsd = Config::CONFIG['host_os'] =~ /freebsd/i
+    @@darwin  = Config::CONFIG['host_os'] =~ /darwin/i
+  end
+
+  def setup
+    @dir   = "/"
+    @stat  = Filesystem.stat(@dir)
+    @mnt   = Filesystem.mounts[0]
+    @size  = 58720256
+    @array = []
+  end
+
+  def test_version
+    assert_equal('0.3.2', Filesystem::VERSION)
+  end
+
+  def test_stat_path
+    assert_respond_to(@stat, :path)
+    assert_equal("/", @stat.path)
+  end
+
+  def test_stat_block_size
+    assert_respond_to(@stat, :block_size)
+    assert_kind_of(Fixnum, @stat.block_size)
+  end
+
+  def test_stat_fragment_size
+    assert_respond_to(@stat, :fragment_size)
+    assert_kind_of(Fixnum, @stat.fragment_size)
+  end
+
+  def test_stat_blocks
+    assert_respond_to(@stat, :blocks)
+    assert_kind_of(Fixnum, @stat.blocks)
+  end
+
+  def test_stat_blocks_free
+    assert_respond_to(@stat, :blocks_free)
+    assert_kind_of(Fixnum, @stat.blocks_free)
+  end
+
+  def test_stat_blocks_available
+    assert_respond_to(@stat, :blocks_available)
+    assert_kind_of(Fixnum, @stat.blocks_available)
+  end
+
+  def test_stat_files
+    assert_respond_to(@stat, :files)
+    assert_kind_of(Fixnum, @stat.files)
+  end
+
+  def test_inodes_alias
+    assert_respond_to(@stat, :inodes)
+    assert_true(@stat.method(:inodes) == @stat.method(:files))
+  end
+
+  def test_stat_files_free
+    assert_respond_to(@stat, :files_free)
+    assert_kind_of(Fixnum, @stat.files_free)
+  end
+
+  def test_stat_inodes_free_alias
+    assert_respond_to(@stat, :inodes_free)
+    assert_true(@stat.method(:inodes_free) == @stat.method(:files_free))
+  end
+
+  def test_stat_files_available
+    assert_respond_to(@stat, :files_available)
+    assert_kind_of(Fixnum, @stat.files_available)
+  end
+
+  def test_stat_inodes_available_alias
+    assert_respond_to(@stat, :inodes_available)
+    assert_true(@stat.method(:inodes_available) == @stat.method(:files_available))
+  end
+
+  def test_stat_filesystem_id
+    assert_respond_to(@stat, :filesystem_id)
+    assert_kind_of(Integer, @stat.filesystem_id)
+  end
+
+  def test_stat_flags
+    assert_respond_to(@stat, :flags)
+    assert_kind_of(Fixnum, @stat.flags)
+  end
+
+  def test_stat_name_max
+    assert_respond_to(@stat, :name_max)
+    assert_kind_of(Fixnum, @stat.name_max)
+  end
+
+  def test_stat_base_type
+    omit_unless(@@solaris, "base_type test skipped except on Solaris")
+
+    assert_respond_to(@stat, :base_type)
+    assert_kind_of(String, @stat.base_type)
+  end
+
+  def test_stat_constants
+    assert_not_nil(Filesystem::Stat::RDONLY)
+    assert_not_nil(Filesystem::Stat::NOSUID)
+
+    omit_unless(@@solaris, "NOTRUNC test skipped except on Solaris")
+
+    assert_not_nil(Filesystem::Stat::NOTRUNC)
+  end
+
+  def test_stat_expected_errors
+    assert_raises(ArgumentError){ Filesystem.stat }
+  end
+
+  def test_fixnum_methods_basic
+    assert_respond_to(@size, :to_kb)
+    assert_respond_to(@size, :to_mb)
+    assert_respond_to(@size, :to_gb)
+  end
+
+  def test_to_kb
+    assert_equal(57344, @size.to_kb)
+  end
+
+  def test_to_mb
+    assert_equal(56, @size.to_mb)
+  end
+
+  def test_to_gb
+    assert_equal(0, @size.to_gb)
+  end
+
+  # Filesystem::Mount tests
+
+  def test_mounts_with_no_block
+    assert_nothing_raised{ @array = Filesystem.mounts }
+    assert_kind_of(Filesystem::Mount, @array[0])
+  end
+
+  def test_mounts_with_block
+    assert_nothing_raised{ Filesystem.mounts{ |m| @array << m } }
+    assert_kind_of(Filesystem::Mount, @array[0])
+  end
+
+  def test_mounts_high_iteration
+    assert_nothing_raised{ 1000.times{ @array = Filesystem.mounts } }
+  end
+
+  def test_mount_name
+    assert_respond_to(@mnt, :name)
+    assert_kind_of(String, @mnt.name)
+  end
+
+  def test_fsname_alias
+    assert_respond_to(@mnt, :fsname)
+    assert_true(@mnt.method(:fsname) == @mnt.method(:name))
+  end
+
+  def test_mount_point
+    assert_respond_to(@mnt, :mount_point)
+    assert_kind_of(String, @mnt.mount_point)
+  end
+
+  def test_dir_alias
+    assert_respond_to(@mnt, :dir)
+    assert_true(@mnt.method(:dir) == @mnt.method(:mount_point))
+  end
+
+  def test_mount_type
+    assert_respond_to(@mnt, :mount_type)
+    assert_kind_of(String, @mnt.mount_type)
+  end
+
+  def test_mount_options
+    assert_respond_to(@mnt, :options)
+    assert_kind_of(String, @mnt.options)
+  end
+
+  def test_opts_alias
+    assert_respond_to(@mnt, :opts)
+    assert_true(@mnt.method(:opts) == @mnt.method(:options))
+  end
+
+  def test_mount_time
+    assert_respond_to(@mnt, :mount_time)
+
+    if @@solaris
+      assert_kind_of(Time, @mnt.mount_time)
+    else
+      assert_nil(@mnt.mount_time)
+    end
+  end
+
+  def test_mount_dump_frequency
+    omit_if(@@solaris || @@freebsd || @@darwin, 'dump_frequency test skipped on this platform')
+    assert_respond_to(@mnt, :dump_frequency)
+    assert_kind_of(Fixnum, @mnt.dump_frequency)
+  end
+
+  def test_freq_alias
+    assert_respond_to(@mnt, :freq)
+    assert_true(@mnt.method(:freq) == @mnt.method(:dump_frequency))
+  end
+
+  def test_mount_pass_number
+    omit_if(@@solaris || @@freebsd || @@darwin, 'pass_number test skipped on this platform')
+    assert_respond_to(@mnt, :pass_number)
+    assert_kind_of(Fixnum, @mnt.pass_number)
+  end
+
+  def test_passno_alias
+    assert_respond_to(@mnt, :passno)
+    assert_true(@mnt.method(:passno) == @mnt.method(:pass_number))
+  end
+
+  def test_mount_point_singleton
+    assert_respond_to(Filesystem, :mount_point)
+    assert_nothing_raised{ Filesystem.mount_point(Dir.pwd) }
+    assert_kind_of(String, Filesystem.mount_point(Dir.pwd))
+  end
+
+  def teardown
+    @dir   = nil
+    @stat  = nil
+    @array = nil
+  end
+
+  def self.shutdown
+    @@solaris = nil
+    @@linux   = nil
+    @@freebsd = nil
+    @@darwin  = nil
+  end
+end

data/test/test_sys_filesystem_windows.rb

@@ -0,0 +1,198 @@
+####################################################################
+# test_sys_filesystem_windows.rb
+#
+# Test case for the Sys::Filesystem.stat method and related stuff.
+# This should be run via the 'rake test' task.
+####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'sys/filesystem'
+require 'rbconfig'
+include Sys
+
+class TC_Sys_Filesystem_Windows < Test::Unit::TestCase
+   def setup
+      @dir   = '/'
+      @stat  = Filesystem.stat(@dir)
+      @mount = Filesystem.mounts[0]
+      @size  = 58720256
+      @array = []
+   end
+
+   def test_version
+      assert_equal('0.3.2', Filesystem::VERSION)
+   end
+
+   def test_stat_path
+      assert_respond_to(@stat, :path)
+      assert_equal("/", @stat.path)
+   end
+
+   def test_stat_block_size
+      assert_respond_to(@stat, :block_size)
+      assert_kind_of(Fixnum, @stat.block_size)
+   end
+
+   def test_stat_fragment_size
+      assert_respond_to(@stat, :fragment_size)
+      assert_nil(@stat.fragment_size)
+   end
+
+   def test_stat_blocks
+      assert_respond_to(@stat, :blocks)
+      assert_kind_of(Fixnum, @stat.blocks)
+   end
+
+   def test_stat_blocks_free
+      assert_respond_to(@stat, :blocks_free)
+      assert_kind_of(Fixnum, @stat.blocks_free)
+   end
+
+   def test_stat_blocks_available
+      assert_respond_to(@stat, :blocks_available)
+      assert_kind_of(Fixnum, @stat.blocks_available)
+   end
+
+   def test_stat_files
+      assert_respond_to(@stat, :files)
+      assert_respond_to(@stat, :inodes)            # Alias
+      assert_nil(@stat.files)
+   end
+
+   def test_stat_files_free
+      assert_respond_to(@stat, :files_free)
+      assert_respond_to(@stat, :inodes_free)       # Alias
+      assert_nil(@stat.files_free)
+   end
+
+   def test_stat_files_available
+      assert_respond_to(@stat, :files_available)
+      assert_respond_to(@stat, :inodes_available)  # Alias
+      assert_nil(@stat.files_available)
+   end
+
+   def test_stat_filesystem_id
+      assert_respond_to(@stat, :filesystem_id)
+      assert_kind_of(Integer, @stat.filesystem_id)
+   end
+
+   def test_stat_flags
+      assert_respond_to(@stat, :flags)
+      assert_kind_of(Fixnum, @stat.flags)
+   end
+
+   def test_stat_name_max
+      assert_respond_to(@stat, :name_max)
+      assert_kind_of(Fixnum, @stat.name_max)
+   end
+
+   def test_stat_base_type
+      assert_respond_to(@stat, :base_type)
+      assert_kind_of(String, @stat.base_type)
+   end
+
+   def test_mount_point_singleton
+      assert_respond_to(Filesystem, :mount_point)
+      assert_nothing_raised{ Filesystem.mount_point(Dir.pwd) }
+      assert_kind_of(String, Filesystem.mount_point(Dir.pwd))
+   end
+
+   def test_constants
+      assert_not_nil(Filesystem::CASE_SENSITIVE_SEARCH)
+      assert_not_nil(Filesystem::CASE_PRESERVED_NAMES)
+      assert_not_nil(Filesystem::UNICODE_ON_DISK)
+      assert_not_nil(Filesystem::PERSISTENT_ACLS)
+      assert_not_nil(Filesystem::FILE_COMPRESSION)
+      assert_not_nil(Filesystem::VOLUME_QUOTAS)
+      assert_not_nil(Filesystem::SUPPORTS_SPARSE_FILES)
+      assert_not_nil(Filesystem::SUPPORTS_REPARSE_POINTS)
+      assert_not_nil(Filesystem::SUPPORTS_REMOTE_STORAGE)
+      assert_not_nil(Filesystem::VOLUME_IS_COMPRESSED)
+      assert_not_nil(Filesystem::SUPPORTS_OBJECT_IDS)
+      assert_not_nil(Filesystem::SUPPORTS_ENCRYPTION)
+      assert_not_nil(Filesystem::NAMED_STREAMS)
+      assert_not_nil(Filesystem::READ_ONLY_VOLUME)
+   end
+
+   def test_stat_expected_errors
+      assert_raises(ArgumentError){ Filesystem.stat }
+   end
+
+   # Filesystem.mounts
+
+   def test_mounts_constructor_basic
+      assert_respond_to(Filesystem, :mounts)
+      assert_nothing_raised{ Filesystem.mounts }
+      assert_nothing_raised{ Filesystem.mounts{} }
+   end
+
+   def test_mounts
+      assert_kind_of(Array, Filesystem.mounts)
+      assert_kind_of(Filesystem::Mount, Filesystem.mounts[0])
+   end
+ 
+   def test_mounts_block_form
+      assert_nil(Filesystem.mounts{})
+      assert_nothing_raised{ Filesystem.mounts{ |mt| @array << mt }}
+      assert_kind_of(Filesystem::Mount, @array[0])
+   end
+
+   def test_mount_name
+      assert_respond_to(@mount, :name)
+      assert_kind_of(String, @mount.name)
+   end
+
+   def test_mount_time
+      assert_respond_to(@mount, :mount_time)
+      assert_kind_of(Time, @mount.mount_time)
+   end
+
+   def test_mount_type
+      assert_respond_to(@mount, :mount_type)
+      assert_kind_of(String, @mount.mount_type)
+   end
+
+   def test_mount_point
+      assert_respond_to(@mount, :mount_point)
+      assert_kind_of(String, @mount.mount_point)
+   end
+
+   def test_mount_options
+      assert_respond_to(@mount, :options)
+      assert_kind_of(String, @mount.options)
+   end
+
+   def test_pass_number
+      assert_respond_to(@mount, :pass_number)
+      assert_nil(@mount.pass_number)
+   end
+
+   def test_frequency
+      assert_respond_to(@mount, :frequency)
+      assert_nil(@mount.frequency)
+   end
+
+   def test_mounts_expected_errors
+      assert_raise(ArgumentError){ Filesystem.mounts("C:\\") }
+   end
+
+   def test_fixnum_methods
+      assert_respond_to(@size, :to_kb)
+      assert_respond_to(@size, :to_mb)
+      assert_respond_to(@size, :to_gb)
+
+      assert_equal(57344, @size.to_kb)
+      assert_equal(56, @size.to_mb)
+      assert_equal(0, @size.to_gb)
+   end
+
+   def teardown
+      @array = nil
+      @dir   = nil
+      @stat  = nil
+      @size  = nil
+      @mount = nil
+   end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: sys-filesystem
+version: !ruby/object:Gem::Version 
+  version: 0.3.2
+platform: x86-mingw32
+authors: 
+- Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-30 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: windows-pr
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.5
+    version: 
+description: "    The sys-filesystem library provides an interface for gathering filesystem\n    information, such as disk space and mount point data.\n"
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+files: 
+- CHANGES
+- examples/example_stat.rb
+- lib/sys/filesystem.rb
+- MANIFEST
+- Rakefile
+- README
+- sys-filesystem.gemspec
+- test/test_sys_filesystem.rb
+- test/test_sys_filesystem_unix.rb
+- test/test_sys_filesystem_windows.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/sysutils
+licenses: 
+- Artistic 2.0
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sysutils
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Ruby interface for getting file system information.
+test_files: 
+- test/test_sys_filesystem.rb