sys-filesystem 1.1.6 → 1.4.3

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

@@ -18,6 +18,8 @@ module Sys
     # Error typically raised if any of the Sys::Filesystem methods fail.
     class Error < StandardError; end
 
+    private_class_method :new
+
     class Mount
       # The name of the volume. This is the device mapping.
       attr_reader :name
@@ -65,8 +67,7 @@ module Sys
       # 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.
+      # The total number of unused blocks available to unprivileged processes.
       attr_reader :blocks_available
 
       # Total number of files/inodes that can be created on the file system.
@@ -94,9 +95,12 @@ module Sys
       # The file system type, e.g. NTFS, FAT, etc.
       attr_reader :base_type
 
-      # Returns the total amount of free space on the partition.
+      # The total amount of free space on the partition.
       attr_reader :bytes_free
 
+      # The amount of free space available to unprivileged processes.
+      attr_reader :bytes_available
+
       alias inodes files
       alias inodes_free files_free
       alias inodes_available files_available
@@ -179,7 +183,7 @@ module Sys
 
       boot_time = get_boot_time
 
-      drives.each{ |drive|
+      drives.each do |drive|
         mount  = Mount.new
         volume = FFI::MemoryPointer.new(:char, MAXPATH)
         fsname = FFI::MemoryPointer.new(:char, MAXPATH)
@@ -204,7 +208,7 @@ module Sys
 
         # Skip unmounted floppies or cd-roms, or inaccessible drives
         unless bool
-          if [5,21].include?(FFI.errno) # ERROR_NOT_READY or ERROR_ACCESS_DENIED
+          if [5, 21].include?(FFI.errno) # ERROR_NOT_READY or ERROR_ACCESS_DENIED
             next
           else
             raise SystemCallError.new('GetVolumeInformation', FFI.errno)
@@ -216,7 +220,7 @@ module Sys
 
         name = 0.chr * MAXPATH
 
-        if QueryDosDeviceA(drive[0,2], name, name.size) == 0
+        if QueryDosDeviceA(drive[0, 2], name, name.size) == 0
           raise SystemCallError.new('QueryDosDevice', FFI.errno)
         end
 
@@ -229,7 +233,7 @@ module Sys
         else
           mounts << mount
         end
-      }
+      end
 
       mounts # Nil if the block form was used.
     end
@@ -242,7 +246,7 @@ module Sys
     #    File.mount_point("C:\\Documents and Settings") # => "C:\\'
     #
     def self.mount_point(file)
-      wfile = FFI::MemoryPointer.from_string(file.wincode)
+      wfile = FFI::MemoryPointer.from_string(file.to_s.wincode)
 
       if PathStripToRootW(wfile)
         wfile.read_string(wfile.size).split("\000\000").first.tr(0.chr, '')
@@ -257,16 +261,33 @@ module Sys
     #
     # Examples:
     #
+    #    # Regular directory
     #    Sys::Filesystem.stat("C:\\")
     #    Sys::Filesystem.stat("C:\\Documents and Settings\\some_user")
     #
+    #    # Pathname
+    #    pathname = Pathname.new("C:\\")
+    #    Sys::Filesystem.stat(pathname)
+    #
+    #    # Dir
+    #    dir = Dir.open("C:\\")
+    #    Sys::Filesystem.stat(dir)
+    #
+    # Note that on Windows you cannot stat a regular file because
+    # Windows won't like it. It must be a directory in some form.
+    #
     def self.stat(path)
+      path = path.path if path.respond_to?(:path) # Dir
+      path = path.to_s if path.respond_to?(:to_s) # Pathname
+
       bytes_avail = FFI::MemoryPointer.new(:ulong_long)
       bytes_free  = FFI::MemoryPointer.new(:ulong_long)
       total_bytes = FFI::MemoryPointer.new(:ulong_long)
 
-      mpoint = mount_point(path)
-      wpath  = path.wincode
+      mpoint = mount_point(path).to_s
+      mpoint << '/' unless mpoint.end_with?('/')
+
+      wpath = path.to_s.wincode
 
       # We need this call for the 64 bit support
       unless GetDiskFreeSpaceExW(wpath, bytes_avail, total_bytes, bytes_free)
@@ -277,24 +298,26 @@ module Sys
       bytes_free  = bytes_free.read_ulong_long
       total_bytes = total_bytes.read_ulong_long
 
-      sectors = FFI::MemoryPointer.new(:ulong_long)
-      bytes   = FFI::MemoryPointer.new(:ulong_long)
-      free    = FFI::MemoryPointer.new(:ulong_long)
-      total   = FFI::MemoryPointer.new(:ulong_long)
+      sectors_ptr = FFI::MemoryPointer.new(:ulong_long)
+      bytes_ptr   = FFI::MemoryPointer.new(:ulong_long)
+      free_ptr    = FFI::MemoryPointer.new(:ulong_long)
+      total_ptr   = FFI::MemoryPointer.new(:ulong_long)
 
       # We need this call for the total/cluster info, which is not in the Ex call.
-      unless GetDiskFreeSpaceW(wpath, sectors, bytes, free, total)
+      unless GetDiskFreeSpaceW(wpath, sectors_ptr, bytes_ptr, free_ptr, total_ptr)
         raise SystemCallError.new('GetDiskFreeSpace', FFI.errno)
       end
 
-      sectors = sectors.read_ulong_long
-      bytes   = bytes.read_ulong_long
-      free    = free.read_ulong_long
-      total   = total.read_ulong_long
+      sectors_per_cluster = sectors_ptr.read_ulong_long
+      bytes_per_sector    = bytes_ptr.read_ulong_long
 
-      block_size   = sectors * bytes
-      blocks_avail = total_bytes / block_size
+      free_ptr.free
+      total_ptr.free
+
+      block_size   = sectors_per_cluster * bytes_per_sector
+      blocks_avail = bytes_avail / block_size
       blocks_free  = bytes_free / block_size
+      total_blocks = total_bytes / block_size
 
       vol_name_ptr   = FFI::MemoryPointer.new(:char, MAXPATH)
       base_type_ptr  = FFI::MemoryPointer.new(:char, MAXPATH)
@@ -314,7 +337,7 @@ module Sys
       )
 
       unless bool
-        raise SystemCallError.new('GetVolumInformation', FFI.errno)
+        raise SystemCallError.new('GetVolumeInformation', FFI.errno)
       end
 
       vol_serial = vol_serial_ptr.read_ulong
@@ -322,16 +345,19 @@ module Sys
       flags      = flags_ptr.read_ulong
       base_type  = base_type_ptr.read_string(base_type_ptr.size).tr(0.chr, '')
 
+      # Lets explicitly free our pointers
       vol_name_ptr.free
       vol_serial_ptr.free
       name_max_ptr.free
       flags_ptr.free
       base_type_ptr.free
+      sectors_ptr.free
+      bytes_ptr.free
 
       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, total_blocks)
       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)
@@ -339,11 +365,39 @@ module Sys
       stat_obj.instance_variable_set(:@flags, flags)
       stat_obj.instance_variable_set(:@filesystem_id, vol_serial)
       stat_obj.instance_variable_set(:@bytes_free, bytes_free)
+      stat_obj.instance_variable_set(:@bytes_available, bytes_avail)
 
       stat_obj.freeze # Read-only object
     end
 
-    private
+    # Associate a volume with a drive letter or a directory on another volume.
+    #
+    def self.mount(target, source)
+      targetw = target.to_s.wincode
+      sourcew = source.to_s.wincode
+
+      volume_namew = (0.chr * 256).wincode
+
+      unless GetVolumeNameForVolumeMountPointW(sourcew, volume_namew, volume_namew.size)
+        raise SystemCallError.new('GetVolumeNameForVolumeMountPoint', FFI.errno)
+      end
+
+      unless SetVolumeMountPointW(targetw, volume_namew)
+        raise SystemCallError.new('SetVolumeMountPoint', FFI.errno)
+      end
+
+      self
+    end
+
+    # Deletes a drive letter or mounted folder.
+    #
+    def self.umount(mount_point)
+      unless DeleteVolumeMountPoint(mount_point)
+        raise SystemCallError.new('DeleteVolumeMountPoint', FFI.errno)
+      end
+
+      self
+    end
 
     # This method is used to get the boot time of the system, which is used
     # for the mount_time attribute within the File.mounts method.
@@ -357,72 +411,37 @@ module Sys
         raise Error, e
       else
         query = 'select LastBootupTime from Win32_OperatingSystem'
-        results = wmi.ExecQuery(query)
-        results.each{ |ole|
-          time_array = Time.parse(ole.LastBootupTime.split('.').first)
-          return Time.mktime(*time_array)
-        }
+        ole = wmi.ExecQuery(query).ItemIndex(0)
+        time_array = Time.parse(ole.LastBootupTime.split('.').first)
+        Time.mktime(*time_array)
       end
     end
 
+    private_class_method :get_boot_time
+
     # Private method that converts filesystem flags into a comma separated
     # list of strings. The presentation is meant as a rough analogue to the
     # way options are presented for Unix filesystems.
     #
     def self.get_options(flags)
-       str = ""
-       str << " casepres" if CASE_PRESERVED_NAMES & flags > 0
-       str << " casesens" if CASE_SENSITIVE_SEARCH & flags > 0
-       str << " compression" if FILE_COMPRESSION & flags > 0
-       str << " namedstreams" if NAMED_STREAMS & flags > 0
-       str << " pacls" if PERSISTENT_ACLS & flags > 0
-       str << " ro" if READ_ONLY_VOLUME & flags > 0
-       str << " encryption" if SUPPORTS_ENCRYPTION & flags > 0
-       str << " objids" if SUPPORTS_OBJECT_IDS & flags > 0
-       str << " rpoints" if SUPPORTS_REPARSE_POINTS & flags > 0
-       str << " sparse" if SUPPORTS_SPARSE_FILES & flags > 0
-       str << " unicode" if UNICODE_ON_DISK & flags > 0
-       str << " compressed" if VOLUME_IS_COMPRESSED & flags > 0
-
-       str.tr!(' ', ',')
-       str = str[1..-1] # Ignore the first comma
-       str
+      str = ''
+      str << ' casepres' if CASE_PRESERVED_NAMES & flags > 0
+      str << ' casesens' if CASE_SENSITIVE_SEARCH & flags > 0
+      str << ' compression' if FILE_COMPRESSION & flags > 0
+      str << ' namedstreams' if NAMED_STREAMS & flags > 0
+      str << ' pacls' if PERSISTENT_ACLS & flags > 0
+      str << ' ro' if READ_ONLY_VOLUME & flags > 0
+      str << ' encryption' if SUPPORTS_ENCRYPTION & flags > 0
+      str << ' objids' if SUPPORTS_OBJECT_IDS & flags > 0
+      str << ' rpoints' if SUPPORTS_REPARSE_POINTS & flags > 0
+      str << ' sparse' if SUPPORTS_SPARSE_FILES & flags > 0
+      str << ' unicode' if UNICODE_ON_DISK & flags > 0
+      str << ' compressed' if VOLUME_IS_COMPRESSED & flags > 0
+
+      str.tr!(' ', ',')
+      str[1..-1] # Ignore the first comma
     end
-  end
-end
-
-# Some convenient methods for converting bytes to kb, mb, and gb.
-#
-class Numeric
-  # call-seq:
-  #  <tt>num</tt>.to_kb
-  #
-  # Returns +num+ in terms of kilobytes.
-  def to_kb
-    self / 1024
-  end
-
-  # call-seq:
-  #  <tt>num</tt>.to_mb
-  #
-  # Returns +num+ in terms of megabytes.
-  def to_mb
-    self / 1048576
-  end
-
-  # call-seq:
-  #  <tt>num</tt>.to_gb
-  #
-  # Returns +num+ in terms of gigabytes.
-  def to_gb
-    self / 1073741824
-  end
 
-  # call-seq:
-  #  <tt>num</tt>.to_gb
-  #
-  # Returns +num+ in terms of terabytes.
-  def to_tb
-    self / 1099511627776
+    private_class_method :get_options
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+
+RSpec.configure do |config|
+  config.filter_run_excluding(:windows) unless Gem.win_platform?
+  config.filter_run_excluding(:unix) if Gem.win_platform?
+end