sys-filesystem 0.2.0-x86-mswin32-60

data/CHANGES

@@ -0,0 +1,15 @@
+== 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/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,72 @@
+= 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
+   
+   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
+   >
+   
+   Filesystem.mounts{ |mount| p mount }
+
+= Notes
+=== MS Windows
+   This is a pure Ruby implementation using the windows-pr package, 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' package.
+   Park Heesob, for implementation and API ideas for the MS Windows version.
+
+= Copyright
+   (C) 2003-2008 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
+   djberg96 at gmail dot com
+   imperator on IRC (irc.freenode.net)

data/Rakefile

@@ -0,0 +1,72 @@
+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
+   Dir.chdir('examples') do
+      FileUtils.rm_rf('sys') if File.exists?('sys')
+   end
+
+   unless CONFIG['host_os'].match('mswin')
+      file = 'sys/filesystem.' + CONFIG['DLEXT']
+      Dir.chdir('ext') do
+         sh 'make distclean' rescue nil
+         rm file if File.exists?(file)
+      end
+   end
+end
+
+desc "Build the sys-filesystem library on UNIX systems (but don't install it)"
+task :build => [:clean] do
+   unless CONFIG['host_os'].match('mswin')
+      file = 'filesystem.' + CONFIG['DLEXT']
+      Dir.chdir('ext') do
+         ruby 'extconf.rb'
+         sh 'make'
+         mv file, 'sys'
+      end
+   end
+end
+
+if CONFIG['host_os'].match('mswin')
+   desc "Install the sys-filesystem library"
+   task :install do
+      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)
+   end
+else
+   desc "Install the sys-filesystem library"
+   task :install => [:build] do
+      Dir.chdir('ext') do
+         sh 'make install'
+      end
+   end
+end
+
+desc "Run the test suite"
+Rake::TestTask.new("test") do |t|
+   unless CONFIG['host_os'].match('mswin')
+      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
+
+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

data/doc/sys-filesystem.txt

@@ -0,0 +1,165 @@
+= Description
+   A Ruby interface for getting filesystem information.
+
+= Synopsis
+   require 'sys/filesystem'
+   include Sys
+
+   p Filesystem.stat("/") # => Sys::Filesystem::Stat object
+   
+   Filesystem.mounts{ |mount|
+      p mount
+   }
+
+= Constants
+== Sys::Filesystem
+VERSION
+   The version of this package, returned as a string.
+
+== Sys::Filesystem::Stat
+RDONLY
+   Read only filesystem.
+
+   See the +flags+ method for more information.
+
+NOSUID
+   Filesystem does not support suid or sgid semantics.
+
+   See the +flags+ method for more information.
+
+NOTRUNC
+   Filesystem does not truncate file names longer than +name_max+. Not
+   supported on all platforms.
+
+   See the +flags+ method for more information.
+
+= Class Methods
+=== Sys::Filesystem
+Sys::Filesystem.stat(path)
+   Returns a Filesystem::Stat object containing information about the
+   +path+ filesystem.
+   
+Sys::Filesystem.mounts
+   Returns an array of Filesystem::Mount objects containing information
+   about the mount points available on your system.
+   
+   In block form this method yields each Mount object in turn instead
+   of returning an array.
+
+= Instance Methods
+=== Sys::Filesystem::Mount
+name
+   The name of the mounted resource.
+   
+   On MS Windows this is the device mapping.
+
+mount_time
+   The last time the volume was mounted.
+   
+   On MS Windows this is your system's boot time.
+
+mount_type
+   The type of mount, e.g. NFS, NTFS.
+
+mount_point
+   The volume mount point.
+   
+   On MS Windows this is the volume letter.
+
+options
+   A list of comma separated options that denote properties of the volume.
+
+pass_number
+   The number of the filesystem check, or nil if not present.
+   
+   This is always nil on MS Windows.
+
+frequency
+   The dump frequency in days, or nil if not present or supported.
+   
+   This is always nil on MS Windows.
+
+=== Sys::Filesystem::Stat
+base_type
+   The filesystem type, e.g. UFS.
+
+block_size
+   The preferred system block size.
+
+blocks
+   The total number of +fragment_size+ blocks in the filesystem.
+
+blocks_available
+   The number of free blocks available to unprivileged processes.
+
+blocks_free
+   The total number of free blocks in the filesystem.
+
+files
+   The total number of files/inodes that can be created.
+
+files_free
+   The total number of free files/inodes on the file system.
+
+filesystem_id
+   The filesystem identifier.
+
+flags
+   A bit mask of flags. See the 'Constants' section for a list of flags.
+
+fragment_size
+   The fragment size, i.e. fundamental file system block size.
+
+inodes
+   Alias for +files+.
+
+inodes_free
+   Alias for +files_free+.
+
+inodes_available
+   Alias for +files_available+.
+
+name_max
+   The maximum length of a file name permitted on the file system.
+
+path
+   The path of the filesystem.
+
+= Fixnum helper methods
+Fixnum#to_gb
+   Returns a number in terms of gigabytes.
+
+Fixnum#to_kb
+   Returns a number in terms of kilobytes
+
+Fixnum#to_mb
+   Returns a number in terms of megabytes
+
+== Known Bugs
+   None that I am aware of. Please log any bugs you find on the project
+   website at http://www.rubyforge.org/projects/sysutils.
+
+== License
+   Ruby's
+    
+== Copyright
+   Copyright 2002-2008, Daniel J. Berger
+
+   All Rights Reserved. This module is free software. It may be used,
+   redistributed and/or modified under the same terms as Ruby itself.
+    
+== 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.
+
+== Acknowledgements
+   Mike Hall for his original source code.
+
+== Author
+   Daniel J. Berger
+   djberg96 at nospam at gmail dot com
+   imperator on IRC (Freenode)
+    
+== See Also
+   mount

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,392 @@
+require 'windows/error'
+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
+
+      # 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
+      
+      VERSION = '0.2.0'
+
+      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:
+      #
+      #    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 a Filesystem::Stat object that contains information about the
+      # +path+ file system.
+      #
+      # Example:
+      #
+      #    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
+
+      # Used to get the boot time of the system, which is used for 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,36 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |gem|
+   gem.name         = 'sys-filesystem'
+   gem.version      = '0.2.0'
+   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.description  = 'A Ruby interface for getting file system information.'
+   gem.test_file    = 'test/test_sys_filesystem.rb'
+   gem.has_rdoc     = true
+   gem.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
+   gem.rubyforge_project = 'sysutils'
+   files = Dir["doc/*"] + Dir["examples/*"] + Dir["test/*"] + Dir["[A-Z]*"]
+   files.delete_if{ |item| item.include?('CVS') }
+   gem.files = files
+end
+
+if $PROGRAM_NAME == __FILE__
+   if RUBY_PLATFORM.match('mswin')
+      spec.required_ruby_version = '>= 1.8.2'
+      spec.files += ['lib/sys/filesystem.rb']
+      spec.platform = Gem::Platform::CURRENT
+      spec.add_dependency('windows-pr', '>= 0.6.0')
+   else
+      spec.required_ruby_version = '>= 1.8.0'
+      spec.extensions = ['ext/extconf.rb']
+      spec.files += Dir["ext/**/*"]
+      spec.extra_rdoc_files << 'ext/sys/filesystem.c'
+   end
+	
+   Gem.manage_gems if Gem::RubyGemsVersion.to_f < 1.0
+   Gem::Builder.new(spec).build
+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'].match('mswin')
+   require 'test_sys_filesystem_windows'
+else
+   require 'test_sys_filesystem_unix'
+end

data/test/test_sys_filesystem_unix.rb

@@ -0,0 +1,234 @@
+####################################################################
+# tc_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
+   end
+
+   def setup
+      @dir   = "/"
+      @stat  = Filesystem.stat(@dir)
+      @mnt   = Filesystem.mounts[0]
+      @size  = 58720256
+      @array = []
+   end
+
+   def test_version
+      assert_equal('0.2.0', 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, "NOTRUNC 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(String, @mnt.mount_time)
+      else
+         assert_nil(@mnt.mount_time)
+      end
+   end
+
+   def test_mount_dump_frequency
+      omit_if(@@solaris, 'dump_frequency test skipped on Solaris')
+      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, 'pass_number test skipped on Solaris')
+      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 teardown
+      @dir   = nil
+      @stat  = nil
+      @array = nil
+   end
+
+   def self.shutdown
+      @@solaris = nil
+      @@linux   = nil
+   end
+end

data/test/test_sys_filesystem_windows.rb

@@ -0,0 +1,192 @@
+####################################################################
+# tc_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.2.0', 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_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,79 @@
+--- !ruby/object:Gem::Specification 
+name: sys-filesystem
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: x86-mswin32-60
+authors: 
+- Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: windows-pr
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.0
+    version: 
+description: A Ruby interface for getting file system information.
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+files: 
+- doc/sys-filesystem.txt
+- examples/example_stat.rb
+- test/test_sys_filesystem.rb
+- test/test_sys_filesystem_unix.rb
+- test/test_sys_filesystem_windows.rb
+- CHANGES
+- doc
+- examples
+- ext
+- lib
+- MANIFEST
+- Rakefile
+- README
+- sys-filesystem.gemspec
+- test
+- lib/sys/filesystem.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/sysutils
+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.1
+signing_key: 
+specification_version: 2
+summary: A Ruby interface for getting file system information.
+test_files: 
+- test/test_sys_filesystem.rb