sys-filesystem 0.1.0-mswin32

data/CHANGES

@@ -0,0 +1,2 @@
+== 0.1.0 - 10-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/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/lib/sys/filesystem.rb

@@ -0,0 +1,184 @@
+require 'windows/error'
+require 'windows/filesystem'
+require 'windows/volume'
+
+module Sys
+   class Filesystem
+      extend Windows::Error
+      extend Windows::FileSystem
+      extend Windows::Volume
+
+      # Error raised if any of the Windows API functions fail.
+      class Error < StandardError; end
+      
+      VERSION = '0.1.0'
+      
+      class Stat
+         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 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
+     
+      # Returns a Filesystem::Stat object that contains information about the
+      # +path+ file system.
+      #
+      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
+   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,34 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |gem|
+   gem.name         = 'sys-filesystem'
+   gem.version      = '0.1.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/tc_filesystem.rb'
+   gem.has_rdoc     = true
+   gem.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
+   gem.rubyforge_project = 'sysutils'
+   files = Dir["doc/*"] + 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::WIN32
+   else
+      spec.required_ruby_version = '>= 1.8.0'
+      spec.extensions = ['extconf.rb']
+      spec.files += ['ext/filesystem.c']
+   end
+	
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

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,61 @@
+--- !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.2
+  version: 
+platform: mswin32
+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
+- examples
+- ext
+- extconf.rb
+- lib
+- MANIFEST
+- README
+- sys-filesystem-0.1.0-mswin32.gem
+- sys-filesystem.gemspec
+- test
+- lib/sys/filesystem.rb
+test_files: 
+- test/tc_filesystem.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+