sys-filesystem 1.3.0 → 1.4.0

data/README

@@ -1,74 +0,0 @@
-= Description
-  A Ruby interface for getting file system information.
-
-= Installation
-  gem install sys-filesystem
-
-= Synopsis
-  require 'sys/filesystem'
-  include Sys
-   
-  # Display information about a particular filesystem.
-  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
-  >
-   
-  # Describe all mount points on the system
-  Filesystem.mounts{ |mount| p mount }
-   
-  # Find the mount point of any particular file
-  puts Filesystem.mount_point('/home/djberge/some_file.txt') => '/home'
-
-= Notes
-  This is a pure Ruby implementation that uses FFI. This means it should work
-  with JRuby, too.
-
-= 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
-  https://github.com/djberg96/sys-filesystem
-
-= Future Plans
-  Add better 64-bit support for Linux and BSD.
-  Other suggestions welcome.
-
-= Acknowledgements
-  Mike Hall, for ideas and code that I borrowed from his 'filesystem' library.
-   
-  Park Heesob, for implementation and API ideas for the MS Windows version.
-   
-  Nobuyoshi Miyokawa, for adding the original FreeBSD and OS X support.
-   
-= License
-  Apache-2.0
-
-= Copyright
-  (C) 2003-2019 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

data/test/test_sys_filesystem.rb

@@ -1,7 +0,0 @@
-$LOAD_PATH.unshift File.dirname(File.expand_path(__FILE__))
-   
-if File::ALT_SEPARATOR
-  require 'test_sys_filesystem_windows'
-else
-  require 'test_sys_filesystem_unix'
-end

data/test/test_sys_filesystem_unix.rb

@@ -1,306 +0,0 @@
-####################################################################
-# test_sys_filesystem_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_Sys_Filesystem_Unix < Test::Unit::TestCase
-  def self.startup
-    @@solaris = RbConfig::CONFIG['host_os'] =~ /solaris/i
-    @@linux   = RbConfig::CONFIG['host_os'] =~ /linux/i
-    @@freebsd = RbConfig::CONFIG['host_os'] =~ /freebsd/i
-    @@darwin  = RbConfig::CONFIG['host_os'] =~ /darwin/i
-  end
-
-  def setup
-    @dir   = "/"
-    @stat  = Filesystem.stat(@dir)
-    @mnt   = Filesystem.mounts[0]
-    @size  = 58720256
-    @array = []
-  end
-
-  def test_version
-    assert_equal('1.3.0', Filesystem::VERSION)
-    assert_true(Filesystem::VERSION.frozen?)
-  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(Numeric, @stat.block_size)
-  end
-
-  def test_block_size_is_a_plausible_value
-    assert_true(@stat.block_size >= 1024)
-    assert_true(@stat.block_size <= 16384)
-  end
-
-  def test_stat_fragment_size
-    assert_respond_to(@stat, :fragment_size)
-    assert_kind_of(Numeric, @stat.fragment_size)
-  end
-
-  def test_stat_blocks
-    assert_respond_to(@stat, :blocks)
-    assert_kind_of(Numeric, @stat.blocks)
-  end
-
-  def test_stat_blocks_free
-    assert_respond_to(@stat, :blocks_free)
-    assert_kind_of(Numeric, @stat.blocks_free)
-  end
-
-  def test_stat_blocks_available
-    assert_respond_to(@stat, :blocks_available)
-    assert_kind_of(Numeric, @stat.blocks_available)
-  end
-
-  def test_stat_files
-    assert_respond_to(@stat, :files)
-    assert_kind_of(Numeric, @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(Numeric, @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(Numeric, @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(Numeric, @stat.flags)
-  end
-
-  def test_stat_name_max
-    assert_respond_to(@stat, :name_max)
-    assert_kind_of(Numeric, @stat.name_max)
-  end
-
-  def test_stat_base_type
-    omit_unless(@@solaris, "base_type 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_bytes_total
-    assert_respond_to(@stat, :bytes_total)
-    assert_kind_of(Numeric, @stat.bytes_total)
-  end
-
-  def test_stat_bytes_free
-    assert_respond_to(@stat, :bytes_free)
-    assert_kind_of(Numeric, @stat.bytes_free)
-    assert_equal(@stat.bytes_free, @stat.blocks_free * @stat.fragment_size)
-  end
-
-  def test_stat_bytes_available
-    assert_respond_to(@stat, :bytes_available)
-    assert_kind_of(Numeric, @stat.bytes_available)
-    assert_equal(@stat.bytes_available, @stat.blocks_available * @stat.fragment_size)
-  end
-
-  def test_stat_bytes_used
-    assert_respond_to(@stat, :bytes_used)
-    assert_kind_of(Numeric, @stat.bytes_used)
-  end
-
-  def test_stat_percent_used
-    assert_respond_to(@stat, :percent_used)
-    assert_kind_of(Float, @stat.percent_used)
-  end
-
-  def test_stat_expected_errors
-    assert_raises(ArgumentError){ Filesystem.stat }
-  end
-
-  def test_stat_case_insensitive
-    expected = @@darwin ? true : false
-    assert_equal(expected, @stat.case_insensitive?)
-    assert_equal(expected, Filesystem.stat(Dir.home).case_insensitive?)
-  end
-
-  def test_stat_case_sensitive
-    expected = @@darwin ? false : true
-    assert_equal(expected, @stat.case_sensitive?)
-    assert_equal(expected, Filesystem.stat(Dir.home).case_sensitive?)
-  end
-
-  def test_numeric_methods_basic
-    assert_respond_to(@size, :to_kb)
-    assert_respond_to(@size, :to_mb)
-    assert_respond_to(@size, :to_gb)
-    assert_respond_to(@size, :to_tb)
-  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(Time, @mnt.mount_time)
-    else
-      assert_nil(@mnt.mount_time)
-    end
-  end
-
-  def test_mount_dump_frequency
-    msg = 'dump_frequency test skipped on this platform'
-    omit_if(@@solaris || @@freebsd || @@darwin, msg)
-    assert_respond_to(@mnt, :dump_frequency)
-    assert_kind_of(Numeric, @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
-    msg = 'pass_number test skipped on this platform'
-    omit_if(@@solaris || @@freebsd || @@darwin, msg)
-    assert_respond_to(@mnt, :pass_number)
-    assert_kind_of(Numeric, @mnt.pass_number)
-  end
-
-  def test_passno_alias
-    assert_respond_to(@mnt, :passno)
-    assert_true(@mnt.method(:passno) == @mnt.method(:pass_number))
-  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_ffi_functions_are_private
-    assert_false(Filesystem.methods.include?('statvfs'))
-    assert_false(Filesystem.methods.include?('strerror'))
-  end
-
-  def test_mount_singleton_method
-    assert_respond_to(Sys::Filesystem, :mount)
-  end
-
-  def test_umount_singleton_method
-    assert_respond_to(Sys::Filesystem, :umount)
-  end
-
-  def teardown
-    @dir   = nil
-    @stat  = nil
-    @array = nil
-  end
-
-  def self.shutdown
-    @@solaris = nil
-    @@linux   = nil
-    @@freebsd = nil
-    @@darwin  = nil
-  end
-end

data/test/test_sys_filesystem_windows.rb

@@ -1,303 +0,0 @@
-####################################################################
-# test_sys_filesystem_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'
-require 'rbconfig'
-require 'pathname'
-include Sys
-
-class TC_Sys_Filesystem_Windows < Test::Unit::TestCase
-  def setup
-    @dir   = 'C:/'
-    @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.3.0', Filesystem::VERSION)
-    assert_true(Filesystem::VERSION.frozen?)
-  end
-
-  test "stat path works as expected" do
-    assert_respond_to(@stat, :path)
-    assert_equal("C:/", @stat.path)
-  end
-
-  test "stat block_size works as expected" do
-    assert_respond_to(@stat, :block_size)
-    assert_kind_of(Numeric, @stat.block_size)
-  end
-
-  test "stat works with or without trailing slash on standard paths" do
-    assert_equal("C:/", Filesystem.stat("C:/").path)
-    assert_equal("C:/Users", Filesystem.stat("C:/Users").path)
-    assert_equal("C:/Users/", Filesystem.stat("C:/Users/").path)
-    assert_equal("C:/Users/", Filesystem.stat("C:/Users/").path)
-  end
-
-  test "stat works with or without trailing slash on UNC paths" do
-    assert_equal("//127.0.0.1/C$", Filesystem.stat("//127.0.0.1/C$").path)
-    assert_equal("//127.0.0.1/C$/", Filesystem.stat("//127.0.0.1/C$/").path)
-    assert_equal("\\\\127.0.0.1\\C$", Filesystem.stat("\\\\127.0.0.1\\C$").path)
-    assert_equal("\\\\127.0.0.1\\C$\\", Filesystem.stat("\\\\127.0.0.1\\C$\\").path)
-  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(Numeric, @stat.blocks)
-  end
-
-  test "stat blocks_free works as expected" do
-    assert_respond_to(@stat, :blocks_free)
-    assert_kind_of(Numeric, @stat.blocks_free)
-  end
-
-  test "stat blocks_available works as expected" do
-    assert_respond_to(@stat, :blocks_available)
-    assert_kind_of(Numeric, @stat.blocks_available)
-  end
-
-  test "block stats return expected relative values" do
-    assert_true(@stat.blocks >= @stat.blocks_free)
-    assert_true(@stat.blocks_free >= @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(Numeric, @stat.flags)
-  end
-
-  test "stat name_max works as expected" do
-    assert_respond_to(@stat, :name_max)
-    assert_kind_of(Numeric, @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 "stat bytes_total basic functionality" do
-    assert_respond_to(@stat, :bytes_total)
-    assert_kind_of(Numeric, @stat.bytes_total)
-  end
-
-  test "stat bytes_free basic functionality" do
-    assert_respond_to(@stat, :bytes_free)
-    assert_kind_of(Numeric, @stat.bytes_free)
-    assert_equal(@stat.bytes_free, @stat.blocks_free * @stat.block_size)
-  end
-
-  test "stat bytes_available basic functionality" do
-    assert_respond_to(@stat, :bytes_available)
-    assert_kind_of(Numeric, @stat.bytes_available)
-    assert_equal(@stat.bytes_available, @stat.blocks_available * @stat.block_size)
-  end
-
-  test "stat bytes_used basic functionality" do
-    assert_respond_to(@stat, :bytes_used)
-    assert_kind_of(Numeric, @stat.bytes_used)
-  end
-
-  test "stat percent_used basic functionality" do
-    assert_respond_to(@stat, :percent_used)
-    assert_kind_of(Float, @stat.percent_used)
-  end
-
-  test "case_insensitive returns expected result" do
-    assert_respond_to(@stat, :case_insensitive?)
-    assert_true(@stat.case_insensitive?)
-  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 "mount_point works with Pathname object" do
-    assert_nothing_raised{ Filesystem.mount_point(Pathname.new("C:/Users/foo")) }
-    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 defaults to root path if proviced" do
-    assert_nothing_raised{ Filesystem.stat("C://Program Files") }
-  end
-
-  test "stat singleton method accepts a Pathname object" do
-    assert_nothing_raised{ Filesystem.stat(Pathname.new("C://Program Files")) }
-  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
-
-  test "stat singleton method raises an error if path is not found" do
-    assert_raise(Errno::ESRCH){ Filesystem.stat("C://Bogus//Dir") }
-  end
-
-   # Filesystem.mounts
-
-  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 Numeric#to_kb method works as expected" do
-    assert_respond_to(@size, :to_kb)
-    assert_equal(57344, @size.to_kb)
-  end
-
-  test "custom Numeric#to_mb method works as expected" do
-    assert_respond_to(@size, :to_mb)
-    assert_equal(56, @size.to_mb)
-  end
-
-  test "custom Numeric#to_gb method works as expected" do
-    assert_respond_to(@size, :to_gb)
-    assert_equal(0, @size.to_gb)
-  end
-
-  # Mount and Unmount
-
-  test "mount singleton method exists" do
-    assert_respond_to(Sys::Filesystem, :mount)
-  end
-
-  test "umount singleton method exists" do
-    assert_respond_to(Sys::Filesystem, :umount)
-  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