sys-filesystem 0.1.1 → 0.2.0

data/CHANGES

@@ -1,3 +1,7 @@
+== 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.

data/MANIFEST

@@ -2,10 +2,12 @@
 * CHANGES
 * Rakefile
 * README
-* install.rb
 * sys-fileystem.gemspec
 * examples/example_stat.rb
+* doc/sys-filesystem.txt
 * ext/extconf.rb
 * ext/filesystem.c
 * lib/sys/filesystem.rb
-* test/tc_filesystem.rb
+* test/test_sys_filesystem.rb
+* test/test_sys_filesystem_unix
+* test/test_sys_filesystem_windows

data/README

@@ -3,15 +3,11 @@
 
 = Prerequisites
 === MS Windows 
-* windows-pr, 0.6.0 or later.
+* windows-pr, 0.9.8 or later.
 
 = Installation
-=== Manual Installation
    rake test (optional)
-   rake install
-=== Gem Installation
-   ruby sys-filesystem.gemspec
-   gem install sys-filesystem-X.Y.Z.gem
+   rake install (non-gem) OR rake install_gem (gem)
 
 = Synopsis
    require 'sys/filesystem'
@@ -19,6 +15,26 @@
    
    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
@@ -35,18 +51,18 @@
    http://www.rubyforge.org/projects/sysutils.
 
 = Future Plans
-   Add support for mount points/volumes.
+   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-2007 Daniel J. Berger
+   (C) 2003-2008 Daniel J. Berger
    All Rights Reserved
 
 = Warranty
-   This package is provided "as is" and without any express or
+   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.
 

data/Rakefile

@@ -1,6 +1,7 @@
 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
@@ -8,35 +9,36 @@ task :clean do
       FileUtils.rm_rf('sys') if File.exists?('sys')
    end
 
-   Dir.chdir('ext') do
-      unless RUBY_PLATFORM.match('mswin')
-         FileUtils.rm_rf('sys') if File.exists?('sys')
-         build_file = 'filesystem.' + Config::CONFIG['DLEXT']
-         sh 'make distclean' if File.exists?(build_file)
+   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 package on UNIX systems (but don't install it)"
+desc "Build the sys-filesystem library on UNIX systems (but don't install it)"
 task :build => [:clean] do
-   Dir.chdir('ext') do
-      unless RUBY_PLATFORM.match('mswin')
+   unless CONFIG['host_os'].match('mswin')
+      file = 'filesystem.' + CONFIG['DLEXT']
+      Dir.chdir('ext') do
          ruby 'extconf.rb'
          sh 'make'
-         build_file = 'filesystem.' + Config::CONFIG['DLEXT']
-         Dir.mkdir('sys') unless File.exists?('sys')
-         FileUtils.cp(build_file, 'sys')
+         mv file, 'sys'
       end
    end
 end
 
-if RUBY_PLATFORM.match('mswin')
-   desc "Install the sys-filesystem package"
+if CONFIG['host_os'].match('mswin')
+   desc "Install the sys-filesystem library"
    task :install do
-      sh 'ruby install.rb'
+      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 package"
+   desc "Install the sys-filesystem library"
    task :install => [:build] do
       Dir.chdir('ext') do
          sh 'make install'
@@ -46,14 +48,14 @@ end
 
 desc "Run the test suite"
 Rake::TestTask.new("test") do |t|
-   if RUBY_PLATFORM.match('mswin')
-      t.libs << 'lib'
-   else
+   unless CONFIG['host_os'].match('mswin')
       task :test => :build
       t.libs << 'ext'
       t.libs.delete('lib')
    end
-   t.test_files = FileList['test/tc_filesystem.rb']
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_sys_filesystem.rb']
 end
 
 desc "Run the example program"

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/ext/extconf.rb

@@ -1,8 +1,11 @@
 require 'mkmf'
 
-have_header("sys/mnttab.h")
-have_header("mntent.h")
+dir_config('filesystem')
+
+have_header("sys/mnttab.h") || have_header("mntent.h")
+
 have_func("statvfs")
+have_func("getextmntent")
 
 if have_header("sys/statvfs.h")
    have_struct_member("struct statvfs", "f_basetype", "sys/statvfs.h")
@@ -10,4 +13,4 @@ else
    have_header("sys/vnode.h")
 end
 
-create_makefile("sys/filesystem")
+create_makefile("sys/filesystem", "sys")

data/ext/{filesystem.c → sys/filesystem.c}

@@ -23,7 +23,7 @@
 #define START_MNT(F,M) fopen(F,M)
 #define GET_MNT(FP,MP) (getmntent(FP,MP) == 0)
 #define END_MNT(F) fclose(F)
-#define MOUNTLIST	"/etc/mnttab"
+#define MOUNTFILE "/etc/mnttab"
 
 #else /* Most flavors of UNIX */
 
@@ -33,12 +33,14 @@
 #define START_MNT(F,M) setmntent(F,M)
 #define GET_MNT(FP,MP) ((MP = getmntent(FP)) != NULL)
 #define END_MNT(F) endmntent(F)
-#define MOUNTLIST	"/etc/mtab"
+#define MOUNTFILE "/etc/mtab"
 #endif
 
 #endif
 
-VALUE mSys, cFilesys, cStat;
+VALUE mSys, cFilesys, cStat, cMount;
+
+static VALUE create_mount_object(struct MNTENT*);
 
 /* call-seq:
  *    Filesystem.stat(path)
@@ -120,6 +122,81 @@ static VALUE fixnum_to_gb(VALUE self){
    return ULL2NUM(NUM2ULONG(self) / 1073741824);
 }
 
+/*
+ * call-seq:
+ *    Filesystem.mounts
+ *    Filesystem.mounts{ ... }
+ *
+ * In block form, yields a Filesystem::Mount object for each mounted filesystem
+ * on your machine. In non-block form, returns an array of Filesystem::Mount
+ * objects instead.
+ *
+ * Example:
+ *
+ *    Filesystem.mounts{ |fs|
+ *       p fs.name            # => e.g. '/dev/dsk/c0t0d0s0', 'proc', etc
+ *       p fs.mount_time      # => e.g. Thu Dec 11 15:07:23 -0700 2008
+ *       p fs.mount_type      # => e.g. 'ufs', 'proc', etc
+ *       p fs.mount_point     # => e.g. '/', '/proc', '/tmp', etc
+ *       p fs.options         # => e.g. "rw,intr,largefiles,logging,xattr,onerror=panic,dev=2200008"
+ *       p fs.pass_number     # => e.g. ???
+ *       p fs.dump_frequency  # => e.g. ???
+ *    }
+ */
+static VALUE fs_mounts(VALUE klass){
+   VALUE v_array;
+   FILE* fp;
+   struct MNTENT* mp;
+#ifdef HAVE_SYS_MNTTAB_H
+	struct MNTENT mt;
+	mp = &mt;
+#endif
+
+   v_array = Qnil;
+
+   if((fp = START_MNT(MOUNTFILE, "r")) == NULL)
+      rb_sys_fail(MOUNTFILE);
+
+   if(rb_block_given_p()){
+      while(GET_MNT(fp, mp))
+         rb_yield(create_mount_object(mp));
+   }
+   else{
+      v_array = rb_ary_new();
+      while(GET_MNT(fp, mp))
+         rb_ary_push(v_array, create_mount_object(mp));
+   }
+
+   END_MNT(fp);
+   
+   return v_array; /* nil in block form */
+}
+
+/* Private function to create a Filesystem object */
+static VALUE create_mount_object(struct MNTENT* mp){
+   VALUE v_mount = rb_funcall(cMount, rb_intern("new"), 0, 0);
+
+#ifdef HAVE_SYS_MNTTAB_H
+   rb_iv_set(v_mount, "@name", rb_tainted_str_new2(mp->mnt_special));
+   rb_iv_set(v_mount, "@mount_point", rb_tainted_str_new2(mp->mnt_mountp));
+   rb_iv_set(v_mount, "@mount_type", rb_tainted_str_new2(mp->mnt_fstype));
+   rb_iv_set(v_mount, "@options", rb_tainted_str_new2(mp->mnt_mntopts));
+   rb_iv_set(v_mount, "@mount_time", rb_time_new(atoi(mp->mnt_time), 0));
+   rb_iv_set(v_mount, "@dump_frequency", Qnil);
+   rb_iv_set(v_mount, "@pass_number", Qnil);
+#else
+   rb_iv_set(v_mount, "@name", rb_tainted_str_new2(mp->mnt_fsname));
+   rb_iv_set(v_mount, "@mount_point", rb_tainted_str_new2(mp->mnt_dir));
+   rb_iv_set(v_mount, "@mount_type", rb_tainted_str_new2(mp->mnt_type));
+   rb_iv_set(v_mount, "@options", rb_tainted_str_new2(mp->mnt_opts));
+   rb_iv_set(v_mount, "@mount_time", Qnil);
+   rb_iv_set(v_mount, "@dump_frequency", INT2NUM(mp->mnt_freq));
+   rb_iv_set(v_mount, "@pass_number", INT2NUM(mp->mnt_passno));
+#endif
+
+   return v_mount;
+}
+
 void Init_filesystem(){
    /* The toplevel namespace */
    mSys = rb_define_module("Sys");
@@ -129,13 +206,48 @@ void Init_filesystem(){
     */
    cFilesys = rb_define_class_under(mSys, "Filesystem", rb_cObject);
 
+   /* Instances of this class are returned by the Filesystem.mount method */
+   cMount = rb_define_class_under(cFilesys, "Mount", rb_cObject);
+
    /* Instances of this class are returned by the Filesystem.stat method */
-   cStat = rb_define_class_under(cFilesys, "Stat", rb_cObject);
+   cStat  = rb_define_class_under(cFilesys, "Stat", rb_cObject);
 
    /* Singleton methods */
+   rb_define_singleton_method(cFilesys, "mounts", fs_mounts, 0);
    rb_define_singleton_method(cFilesys, "stat", fs_stat, 1);
 
-   /* Stat accessors */
+   /* Filesystem::Mount accessors */
+
+   /* The name of the mounted resource */
+   rb_define_attr(cMount, "name", 1, 0);
+
+   /* The mount point/directory */
+   rb_define_attr(cMount, "mount_point", 1, 0);
+
+   /* The type of the file system mount, e.g. 'ufs', 'nfs', etc */
+   rb_define_attr(cMount, "mount_type", 1, 0);
+
+   /* A list of comma separated options for the mount, e.g. 'rw', etc */
+   rb_define_attr(cMount, "options", 1, 0);
+
+   /* The time the file system was mounted or nil if not supported */
+   rb_define_attr(cMount, "mount_time", 1, 0);
+
+   /* The dump frequency in days (or nil if not supported) */
+   rb_define_attr(cMount, "dump_frequency", 1, 0);
+
+   /* The pass number of the file system check or nil if not supported */
+   rb_define_attr(cMount, "pass_number", 1, 0);
+
+   /* Filesystem::Mount Aliases */
+
+   rb_define_alias(cMount, "fsname", "name");
+   rb_define_alias(cMount, "dir", "mount_point");
+   rb_define_alias(cMount, "opts", "options");
+   rb_define_alias(cMount, "passno", "pass_number");
+   rb_define_alias(cMount, "freq", "dump_frequency");
+
+   /* Filesystem::Stat accessors */
 
    /* The path of the file system */
    rb_define_attr(cStat, "path", 1, 0);
@@ -178,8 +290,8 @@ void Init_filesystem(){
 
    /* Constants */
 
-   /* 0.1.1: The version of this package */
-   rb_define_const(cFilesys, "VERSION", rb_str_new2("0.1.1"));
+   /* 0.2.0: The version of this library (a String) */
+   rb_define_const(cFilesys, "VERSION", rb_str_new2("0.2.0"));
 
    /* 0x00000001: Read only file system */
    rb_define_const(cStat, "RDONLY", INT2FIX(ST_RDONLY));

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

@@ -1,57 +1,67 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: sys-filesystem
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-03-28 00:00:00 -06:00
-summary: A Ruby interface for getting file system information.
-require_paths: 
-- lib
-email: djberg96@gmail.com
-homepage: http://www.rubyforge.org/projects/sysutils
-rubyforge_project: sysutils
-description: A Ruby interface for getting file system information.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.0
-  version: 
+  version: 0.2.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Daniel J. Berger
-files: 
-- test/tc_filesystem.rb
-- test/tc_unix.rb
-- test/tc_windows.rb
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A Ruby interface for getting file system information.
+email: djberg96@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
 - CHANGES
+- README
+- MANIFEST
+- ext/sys/filesystem.c
+files: 
+- doc/sys-filesystem.txt
+- examples/example_stat.rb
+- test/test_sys_filesystem_unix.rb
+- test/test_sys_filesystem.rb
+- test/test_sys_filesystem_windows.rb
 - MANIFEST
 - README
+- CHANGES
 - Rakefile
 - ext/extconf.rb
-- ext/filesystem.c
-test_files: 
-- test/tc_filesystem.rb
+- ext/sys
+- ext/sys/filesystem.c
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/sysutils
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: 
-- CHANGES
-- README
-- MANIFEST
-- ext/filesystem.c
-executables: []
-
-extensions: 
-- ext/extconf.rb
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+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

data/test/tc_filesystem.rb

@@ -1,7 +0,0 @@
-$LOAD_PATH.unshift File.dirname(File.expand_path(__FILE__))
-
-if RUBY_PLATFORM.match('mswin')
-   require 'tc_windows'
-else
-   require 'tc_unix'
-end

data/test/tc_unix.rb

@@ -1,118 +0,0 @@
-####################################################################
-# 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 'test/unit'
-require 'sys/filesystem'
-include Sys
-
-class TC_Filesystem_Unix < Test::Unit::TestCase
-   def setup
-      @dir = "/"
-      @stat = Filesystem.stat(@dir)
-      @size = 58720256
-   end
-
-   def test_version
-      assert_equal('0.1.1', 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_respond_to(@stat, :inodes)            # Alias
-      assert_kind_of(Fixnum, @stat.files)
-   end
-
-   def test_stat_files_free
-      assert_respond_to(@stat, :files_free)
-      assert_respond_to(@stat, :inodes_free)       # Alias
-      assert_kind_of(Fixnum, @stat.files_free)
-   end
-
-   def test_stat_files_available
-      assert_respond_to(@stat, :files_available)
-      assert_respond_to(@stat, :inodes_available)  # Alias
-      assert_kind_of(Fixnum, @stat.files_available)
-   end
-
-   def test_stat_filesystem_id
-      assert_respond_to(@stat, :filesystem_id)
-      assert_kind_of(Fixnum, @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
-
-   unless RUBY_PLATFORM =~ /linux|darwin/i
-      def test_stat_base_type
-         assert_respond_to(@stat, :base_type)
-         assert_kind_of(String, @stat.base_type)
-      end
-   end
-
-   def test_stat_constants
-      assert_not_nil(Filesystem::Stat::RDONLY)
-      assert_not_nil(Filesystem::Stat::NOSUID)
-      unless RUBY_PLATFORM =~ /linux|darwin/i
-         assert_not_nil(Filesystem::Stat::NOTRUNC)
-      end
-   end
-
-   def test_stat_expected_errors
-      assert_raises(ArgumentError){ Filesystem.stat }
-   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
-      @dir  = nil
-      @stat = nil
-   end
-end

data/test/tc_windows.rb

@@ -1,127 +0,0 @@
-####################################################################
-# tc_windows.rb
-#
-# Test case for the Sys::Filesystem.stat method and related stuff.
-# This should be run via the 'rake test' task.
-####################################################################
-require 'test/unit'
-require 'sys/filesystem'
-include Sys
-
-class TC_Filesystem_Unix < Test::Unit::TestCase
-   def setup
-      @dir = "/"
-      @stat = Filesystem.stat(@dir)
-      @size = 58720256
-   end
-
-   def test_version
-      assert_equal('0.1.1', 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
-
-   unless RUBY_PLATFORM.match('linux')
-      def test_stat_base_type
-         assert_respond_to(@stat, :base_type)
-         assert_kind_of(String, @stat.base_type)
-      end
-   end
-
-   def test_stat_constants
-      assert_not_nil(Filesystem::Stat::CASE_SENSITIVE_SEARCH)
-      assert_not_nil(Filesystem::Stat::CASE_PRESERVED_NAMES)
-      assert_not_nil(Filesystem::Stat::UNICODE_ON_DISK)
-      assert_not_nil(Filesystem::Stat::PERSISTENT_ACLS)
-      assert_not_nil(Filesystem::Stat::FILE_COMPRESSION)
-      assert_not_nil(Filesystem::Stat::VOLUME_QUOTAS)
-      assert_not_nil(Filesystem::Stat::SUPPORTS_SPARSE_FILES)
-      assert_not_nil(Filesystem::Stat::SUPPORTS_REPARSE_POINTS)
-      assert_not_nil(Filesystem::Stat::SUPPORTS_REMOTE_STORAGE)
-      assert_not_nil(Filesystem::Stat::VOLUME_IS_COMPRESSED)
-      assert_not_nil(Filesystem::Stat::SUPPORTS_OBJECT_IDS)
-      assert_not_nil(Filesystem::Stat::SUPPORTS_ENCRYPTION)
-      assert_not_nil(Filesystem::Stat::NAMED_STREAMS)
-      assert_not_nil(Filesystem::Stat::READ_ONLY_VOLUME)
-   end
-
-   def test_stat_expected_errors
-      assert_raises(ArgumentError){ Filesystem.stat }
-   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
-      @dir  = nil
-      @stat = nil
-   end
-end