sys-filesystem 1.0.0 → 1.1.0

data/lib/windows/sys/filesystem/constants.rb

@@ -0,0 +1,22 @@
+module Sys
+  class Filesystem
+    module Constants
+      MAXPATH = 260
+
+      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
+    end
+  end
+end

data/lib/windows/sys/filesystem/functions.rb

@@ -0,0 +1,36 @@
+require 'ffi'
+
+module Sys
+  class Filesystem
+    module Functions
+      extend FFI::Library
+      ffi_lib :kernel32
+
+      # Make FFI functions private
+      module FFI::Library
+        def attach_pfunc(*args)
+          attach_function(*args)
+          private args[0]
+        end
+      end
+
+      attach_pfunc :GetDiskFreeSpaceW, [:buffer_in, :pointer, :pointer, :pointer, :pointer], :bool
+      attach_pfunc :GetDiskFreeSpaceExW, [:buffer_in, :pointer, :pointer, :pointer], :bool
+      attach_pfunc :GetLogicalDriveStringsA, [:ulong, :pointer], :ulong
+
+      attach_pfunc :GetVolumeInformationA,
+        [:buffer_in, :pointer, :ulong, :pointer, :pointer, :pointer, :pointer, :ulong],
+        :bool
+
+      attach_pfunc :GetVolumeInformationW,
+        [:buffer_in, :pointer, :ulong, :pointer, :pointer, :pointer, :pointer, :ulong],
+        :bool
+
+      attach_pfunc :QueryDosDeviceA, [:buffer_in, :buffer_out, :ulong], :ulong
+
+      ffi_lib :shlwapi
+
+      attach_pfunc :PathStripToRootW, [:pointer], :bool
+    end
+  end
+end

data/lib/windows/sys/filesystem/helper.rb

@@ -0,0 +1,7 @@
+class String
+  # Convenience method for converting strings to UTF-16LE for wide character
+  # functions that require it.
+  def wincode
+    (self.tr(File::SEPARATOR, File::ALT_SEPARATOR) + 0.chr).encode('UTF-16LE')
+  end
+end

data/sys-filesystem.gemspec

@@ -2,11 +2,10 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'sys-filesystem'
-  spec.version   = '1.0.0'
+  spec.version   = '1.1.0'
   spec.author    = 'Daniel J. Berger'
   spec.email     = 'djberg96@gmail.com'
-  spec.homepage  = 'http://www.rubyforge.org/projects/sysutils'
-  spec.platform  = Gem::Platform::RUBY
+  spec.homepage  = 'https://github.com/djberg96/sys-filesystem'
   spec.summary   = 'A Ruby interface for getting file system information.'
   spec.test_file = 'test/test_sys_filesystem.rb'
   spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
@@ -15,7 +14,8 @@ Gem::Specification.new do |spec|
   spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
   spec.rubyforge_project = 'sysutils'
 
-  spec.add_development_dependency('test-unit', '>= 2.1.1')
+  spec.add_dependency('ffi')
+  spec.add_development_dependency('test-unit', '>= 2.5.0')
 
   spec.description = <<-EOF
     The sys-filesystem library provides an interface for gathering filesystem

data/test/test_sys_filesystem_unix.rb

@@ -4,10 +4,7 @@
 # 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 'test-unit'
 require 'sys/filesystem'
 include Sys
 
@@ -28,7 +25,7 @@ class TC_Sys_Filesystem_Unix < Test::Unit::TestCase
   end
 
   def test_version
-    assert_equal('1.0.0', Filesystem::VERSION)
+    assert_equal('1.1.0', Filesystem::VERSION)
   end
 
   def test_stat_path
@@ -241,7 +238,6 @@ class TC_Sys_Filesystem_Unix < Test::Unit::TestCase
   end
 
   def test_ffi_functions_are_private
-    methods = Filesystem.methods(false).map{ |e| e.to_s }
     assert_false(Filesystem.methods.include?('statvfs'))
     assert_false(Filesystem.methods.include?('strerror'))
   end

data/test/test_sys_filesystem_windows.rb

@@ -4,195 +4,219 @@
 # 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 '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('1.0.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_mount_point_singleton
-      assert_respond_to(Filesystem, :mount_point)
-      assert_nothing_raised{ Filesystem.mount_point(Dir.pwd) }
-      assert_kind_of(String, Filesystem.mount_point(Dir.pwd))
-   end
-
-   def test_constants
-      assert_not_nil(Filesystem::CASE_SENSITIVE_SEARCH)
-      assert_not_nil(Filesystem::CASE_PRESERVED_NAMES)
-      assert_not_nil(Filesystem::UNICODE_ON_DISK)
-      assert_not_nil(Filesystem::PERSISTENT_ACLS)
-      assert_not_nil(Filesystem::FILE_COMPRESSION)
-      assert_not_nil(Filesystem::VOLUME_QUOTAS)
-      assert_not_nil(Filesystem::SUPPORTS_SPARSE_FILES)
-      assert_not_nil(Filesystem::SUPPORTS_REPARSE_POINTS)
-      assert_not_nil(Filesystem::SUPPORTS_REMOTE_STORAGE)
-      assert_not_nil(Filesystem::VOLUME_IS_COMPRESSED)
-      assert_not_nil(Filesystem::SUPPORTS_OBJECT_IDS)
-      assert_not_nil(Filesystem::SUPPORTS_ENCRYPTION)
-      assert_not_nil(Filesystem::NAMED_STREAMS)
-      assert_not_nil(Filesystem::READ_ONLY_VOLUME)
-   end
-
-   def test_stat_expected_errors
-      assert_raises(ArgumentError){ Filesystem.stat }
-   end
+  def setup
+    @dir   = '/'
+    @stat  = Filesystem.stat(@dir)
+    @mount = Filesystem.mounts[0]
+    @size  = 58720256
+    @array = []
+  end
+
+  test "version number is set to the expected value" do
+    assert_equal('1.1.0', Filesystem::VERSION)
+  end
+
+  test "stat path works as expected" do
+    assert_respond_to(@stat, :path)
+    assert_equal("/", @stat.path)
+  end
+
+  test "stat block_size works as expected" do
+    assert_respond_to(@stat, :block_size)
+    assert_kind_of(Fixnum, @stat.block_size)
+  end
+
+  test "stat fragment_size works as expected" do
+    assert_respond_to(@stat, :fragment_size)
+    assert_nil(@stat.fragment_size)
+  end
+
+  test "stat blocks works as expected" do
+    assert_respond_to(@stat, :blocks)
+    assert_kind_of(Fixnum, @stat.blocks)
+  end
+
+  test "stat blocks_free works as expected" do
+    assert_respond_to(@stat, :blocks_free)
+    assert_kind_of(Fixnum, @stat.blocks_free)
+  end
+
+  test "stat blocks_available works as expected" do
+    assert_respond_to(@stat, :blocks_available)
+    assert_kind_of(Fixnum, @stat.blocks_available)
+  end
+
+  test "stat files works as expected" do
+    assert_respond_to(@stat, :files)
+    assert_nil(@stat.files)
+  end
+
+  test "stat inodes is an alias for files" do
+    assert_alias_method(@stat, :inodes, :files)
+  end
+
+  test "stat files_free works as expected" do
+    assert_respond_to(@stat, :files_free)
+    assert_nil(@stat.files_free)
+  end
+
+  test "stat inodes_free is an alias for files_free" do
+    assert_respond_to(@stat, :inodes_free)
+  end
+
+  test "stat files available works as expected" do
+    assert_respond_to(@stat, :files_available)
+    assert_nil(@stat.files_available)
+  end
+
+  test "stat inodes_available is an alias for files_available" do
+    assert_alias_method(@stat, :inodes_available, :files_available)
+  end
+
+  test "stat filesystem_id works as expected" do
+    assert_respond_to(@stat, :filesystem_id)
+    assert_kind_of(Integer, @stat.filesystem_id)
+  end
+
+  test "stat flags works as expected" do
+    assert_respond_to(@stat, :flags)
+    assert_kind_of(Fixnum, @stat.flags)
+  end
+
+  test "stat name_max works as expected" do
+    assert_respond_to(@stat, :name_max)
+    assert_kind_of(Fixnum, @stat.name_max)
+  end
+
+  test "stat base_type works as expected" do
+    assert_respond_to(@stat, :base_type)
+    assert_kind_of(String, @stat.base_type)
+  end
+
+  test "mount_point singleton method basic functionality" do
+    assert_respond_to(Filesystem, :mount_point)
+    assert_nothing_raised{ Filesystem.mount_point(Dir.pwd) }
+    assert_kind_of(String, Filesystem.mount_point(Dir.pwd))
+  end
+
+  test "mount_point singleton method returns expected value" do
+    assert_equal("C:\\", Filesystem.mount_point("C:\\Users\\foo"))
+    assert_equal("\\\\foo\\bar", Filesystem.mount_point("//foo/bar/baz"))
+  end
+
+  test "filesystem constants are defined" do
+    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
+
+  test "stat singleton method requires a single argument" do
+    assert_raise(ArgumentError){ Filesystem.stat }
+    assert_raise(ArgumentError){ Filesystem.stat(Dir.pwd, Dir.pwd) }
+  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
+  test "mounts singleton method basic functionality" do
+    assert_respond_to(Filesystem, :mounts)
+    assert_nothing_raised{ Filesystem.mounts }
+    assert_nothing_raised{ Filesystem.mounts{} }
+  end
+
+  test "mounts singleton method returns the expected value" do
+    assert_kind_of(Array, Filesystem.mounts)
+    assert_kind_of(Filesystem::Mount, Filesystem.mounts[0])
+  end
+
+  test "mounts singleton method works as expected when a block is provided" do
+    assert_nil(Filesystem.mounts{})
+    assert_nothing_raised{ Filesystem.mounts{ |mt| @array << mt }}
+    assert_kind_of(Filesystem::Mount, @array[0])
+  end
+
+  test "mount name works as expected" do
+    assert_respond_to(@mount, :name)
+    assert_kind_of(String, @mount.name)
+  end
+
+  test "mount time works as expected" do
+    assert_respond_to(@mount, :mount_time)
+    assert_kind_of(Time, @mount.mount_time)
+  end
+
+  test "mount type works as expected" do
+    assert_respond_to(@mount, :mount_type)
+    assert_kind_of(String, @mount.mount_type)
+  end
+
+  test "mount point works as expected" do
+    assert_respond_to(@mount, :mount_point)
+    assert_kind_of(String, @mount.mount_point)
+  end
+
+  test "mount options works as expected" do
+    assert_respond_to(@mount, :options)
+    assert_kind_of(String, @mount.options)
+  end
+
+  test "mount pass_number works as expected" do
+    assert_respond_to(@mount, :pass_number)
+    assert_nil(@mount.pass_number)
+  end
+
+  test "mount frequency works as expected" do
+    assert_respond_to(@mount, :frequency)
+    assert_nil(@mount.frequency)
+  end
+
+  test "mounts singleton method does not accept any arguments" do
+    assert_raise(ArgumentError){ Filesystem.mounts("C:\\") }
+  end
+
+  test "custom Fixnum#to_kb method works as expected" do
+    assert_respond_to(@size, :to_kb)
+    assert_equal(57344, @size.to_kb)
+  end
+
+  test "custom Fixnum#to_mb method works as expected" do
+    assert_respond_to(@size, :to_mb)
+    assert_equal(56, @size.to_mb)
+  end
+
+  test "custom Fixnum#to_gb method works as expected" do
+    assert_respond_to(@size, :to_gb)
+    assert_equal(0, @size.to_gb)
+  end
+
+  # FFI
+
+  test "internal ffi functions are not public" do
+    assert_false(Filesystem.methods.include?(:GetVolumeInformationA))
+    assert_false(Filesystem.instance_methods.include?(:GetVolumeInformationA))
+  end
+
+  def teardown
+    @array = nil
+    @dir   = nil
+    @stat  = nil
+    @size  = nil
+    @mount = nil
+  end
 end