sys-filesystem 0.1.0

data/CHANGES

@@ -0,0 +1,2 @@
+== 0.1.0 - 17-Nov-2006
+* Initial release.  Alpha. Code is stable, but API is not.

data/MANIFEST

@@ -0,0 +1,14 @@
+MANIFEST
+CHANGES
+README
+install.rb
+extconf.rb
+sys-fileystem.gemspec
+
+examples/example_stat.rb
+
+ext/filesystem.c
+
+lib/sys/filesystem.rb
+
+test/tc_filesystem.rb

data/README

@@ -0,0 +1,49 @@
+= Description
+   A Ruby interface for getting file system information.
+
+= Prerequisites
+=== MS Windows 
+* windows-pr, 0.6.0 or later.
+
+= Installation
+=== MS Windows:
+   ruby test/tc_filesystem.rb (optional)
+   ruby install.rb
+
+=== All other platforms:
+   ruby extconf.rb
+   make
+   ruby test/tc_filesystem.rb (optional)
+   make install
+
+= 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.
+
+= Known Bugs
+   None that I'm aware of.  Please report bugs on the project page at
+   http://www.rubyforge.org/projects/sysutils.
+
+= Future Plans
+   Add support for mount points/volumes.
+
+= 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-2006 Daniel J. Berger
+   All Rights Reserved
+
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+= Author
+   Daniel J. Berger
+   djberg96 at gmail dot com
+   imperator on IRC (irc.freenode.net)

data/ext/filesystem.c

@@ -0,0 +1,181 @@
+/********************************************************************
+ * filesystem.c
+ *
+ * This is the source file for the sys-filesystem package for Ruby.
+ * This is for UNIX platforms only.
+ ********************************************************************/
+#include <ruby.h>
+
+#include <sys/types.h>
+#include <sys/statvfs.h>
+
+#ifdef HAVE_SYS_MNTTAB_H
+
+/* Solaris */
+#include <sys/mnttab.h>
+#define MNTENT	mnttab
+#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"
+
+#else
+
+/* All other flavors of UNIX */
+#include <mntent.h>
+#define MNTENT	mntent
+#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"
+
+#endif
+
+VALUE mSys, cFilesys, cStat;
+
+/* call-seq:
+ *    Filesystem.stat(path)
+ *
+ * Returns a a Filesystem::Stat object containing information about the +path+
+ * file system.
+ */
+static VALUE fs_stat(VALUE klass, VALUE v_path){
+   VALUE v_stat;
+   struct statvfs fs;
+   char* path = StringValuePtr(v_path);
+
+   if(statvfs(path, &fs) < 0)
+      rb_sys_fail("statvfs");
+
+   v_stat = rb_funcall(cStat, rb_intern("new"), 0, 0);
+
+   rb_iv_set(v_stat, "@path", v_path);
+   rb_iv_set(v_stat, "@block_size", ULONG2NUM(fs.f_bsize));
+   rb_iv_set(v_stat, "@fragment_size", ULONG2NUM(fs.f_frsize));
+   rb_iv_set(v_stat, "@blocks", LONG2NUM(fs.f_blocks));
+   rb_iv_set(v_stat, "@blocks_free", LONG2NUM(fs.f_bfree));
+   rb_iv_set(v_stat, "@blocks_available", LONG2NUM(fs.f_bavail));
+   rb_iv_set(v_stat, "@files", LONG2NUM(fs.f_files));
+   rb_iv_set(v_stat, "@files_free", LONG2NUM(fs.f_ffree));
+   rb_iv_set(v_stat, "@files_available", LONG2NUM(fs.f_favail));
+   rb_iv_set(v_stat, "@filesystem_id", ULONG2NUM(fs.f_fsid));
+   rb_iv_set(v_stat, "@flags", ULONG2NUM(fs.f_flag));
+   rb_iv_set(v_stat, "@name_max", ULONG2NUM(fs.f_namemax));
+
+#ifdef HAVE_ST_F_BASETYPE
+   rb_iv_set(v_stat, "@base_type", rb_str_new2(fs.f_basetype));
+#endif
+
+   return rb_obj_freeze(v_stat);
+}
+
+/* Convenient methods for converting bytes to kilobytes, megabytes or
+ * gigabytes.
+ */
+
+/*
+ * call-seq:
+ *    <tt>fix</tt>.to_kb
+ *
+ * Returns +fix+ in terms of kilobytes.
+ */
+static VALUE fixnum_to_kb(VALUE self){
+   return ULL2NUM(NUM2ULONG(self) / 1024);
+}
+
+/*
+ * call-seq:
+ *    <tt>fix</tt>.to_mb
+ *
+ * Returns +fix+ in terms of megabytes.
+ */
+static VALUE fixnum_to_mb(VALUE self){
+   return ULL2NUM(NUM2ULONG(self) / 1048576);
+}
+
+/*
+ * call-seq:
+ *    <tt>fix</tt>.to_gb
+ *
+ * Returns +fix+ in terms of gigabytes.
+ */
+static VALUE fixnum_to_gb(VALUE self){
+   return ULL2NUM(NUM2ULONG(self) / 1073741824);
+}
+
+void Init_filesystem(){
+   /* Classes and Modules */
+   mSys     = rb_define_module("Sys");
+   cFilesys = rb_define_class_under(mSys, "Filesystem", rb_cObject);
+   cStat    = rb_define_class_under(cFilesys, "Stat", rb_cObject);
+
+   /* Singleton methods */
+   rb_define_singleton_method(cFilesys, "stat", fs_stat, 1);
+
+   /* Stat accessors */
+
+   /* The path of the file system */
+   rb_define_attr(cStat, "path", 1, 0);
+
+   /* The preferred system block size */
+   rb_define_attr(cStat, "block_size", 1, 0);
+
+   /* The fragment size, i.e. fundamental file system block size */
+   rb_define_attr(cStat, "fragment_size", 1, 0);
+
+   /* The total number of +fragment_size+ blocks in the file system */
+   rb_define_attr(cStat, "blocks", 1, 0);
+
+   /* The total number of free blocks in the file system */
+   rb_define_attr(cStat, "blocks_free", 1, 0);
+
+   /* The number of free blocks available to unprivileged processes */
+   rb_define_attr(cStat, "blocks_available", 1, 0);
+
+   /* The total number of files/inodes that can be created */
+   rb_define_attr(cStat, "files", 1, 0);
+
+   /* The total number of free files/inodes on the file system */
+   rb_define_attr(cStat, "files_free", 1, 0);
+
+   /* The number of free files/inodes available to unprivileged processes */
+   rb_define_attr(cStat, "files_available", 1, 0);
+
+   /* The file system identifier */
+   rb_define_attr(cStat, "filesystem_id", 1, 0);
+
+   /* The file system type, e.g. UFS */
+   rb_define_attr(cStat, "base_type", 1, 0);
+
+   /* A bit mask of flags.  See the <tt>Constants</tt> for a list of flags */
+   rb_define_attr(cStat, "flags", 1, 0);
+
+   /* The maximum length of a file name permitted on the file system */
+   rb_define_attr(cStat, "name_max", 1, 0);
+
+   /* Constants */
+
+   /* The version of this package */
+   rb_define_const(cFilesys, "VERSION", rb_str_new2("0.1.0"));
+
+   /* Read only file system */
+   rb_define_const(cStat, "RDONLY", INT2FIX(ST_RDONLY));
+
+   /* File system does not support suid or sgid semantics */
+   rb_define_const(cStat, "NOSUID", INT2FIX(ST_NOSUID));
+
+#ifdef ST_NOTRUNC
+   /* File system does not truncate file names longer than +name_max+ */
+   rb_define_const(cStat, "NOTRUNC", INT2FIX(ST_NOTRUNC));
+#endif
+
+   /* Aliases */
+   rb_define_alias(cStat, "inodes", "files");
+   rb_define_alias(cStat, "inodes_free", "files_free");
+   rb_define_alias(cStat, "inodes_available", "files_available");
+
+   /* Convenient methods for Fixnum */
+   rb_define_method(rb_cFixnum, "to_kb", fixnum_to_kb, 0);
+   rb_define_method(rb_cFixnum, "to_mb", fixnum_to_mb, 0);
+   rb_define_method(rb_cFixnum, "to_gb", fixnum_to_gb, 0);
+}

data/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+require 'fileutils'
+
+have_header("sys/mnttab.h")
+have_struct_member("struct statvfs", "f_basetype", "sys/statvfs.h")
+
+FileUtils.cp('ext/filesystem.c', '.')
+
+create_makefile("sys/filesystem")

data/test/tc_filesystem.rb

@@ -0,0 +1,7 @@
+$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

@@ -0,0 +1,129 @@
+####################################################################
+# tc_unix.rb
+#
+# Test case for the Sys::Filesystem.stat method and related stuff.
+####################################################################
+base = File.basename(Dir.pwd)
+
+if base == 'test' || base =~ /filesystem/i
+   require 'fileutils'
+   require 'rbconfig'
+   Dir.chdir('..') if base == 'test'
+   Dir.mkdir('sys') rescue nil
+   file = 'filesystem.' + Config::CONFIG['DLEXT']
+   FileUtils.cp(file, 'sys')
+   $LOAD_PATH.unshift(Dir.pwd)
+end
+
+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.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_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.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::RDONLY)
+      assert_not_nil(Filesystem::Stat::NOSUID)
+      unless RUBY_PLATFORM.match('linux')
+         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

@@ -0,0 +1,129 @@
+####################################################################
+# tc_unix.rb
+#
+# Test case for the Sys::Filesystem.stat method and related stuff.
+####################################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'test'
+$LOAD_PATH.unshift(Dir.pwd + '/lib')
+
+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.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
+
+   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

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: sys-filesystem
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-11-17 00:00:00 -07: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: 
+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
+- CHANGES
+- MANIFEST
+- README
+- extconf.rb
+- ext/filesystem.c
+test_files: 
+- test/tc_filesystem.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+executables: []
+
+extensions: 
+- extconf.rb
+requirements: []
+
+dependencies: []
+