win32-file 0.5.3 → 0.5.4

data/CHANGES

@@ -1,3 +1,9 @@
+== 0.5.4 - 8-Apr-2007
+* Now runs -w clean.
+* Added a Rakefile. Manual installation and testing should now be handled
+  by the Rake tasks.
+* Some updates to the README file.
+
 == 0.5.3 - 2-Nov-2006
 * Added the File.lstat method.  It's abscence caused problems for cross
   platform packages (such as the 'find' module) which were expecting a result

data/MANIFEST

@@ -1,16 +1,15 @@
-CHANGES
-MANIFEST
-README
-install.rb
-win32-file.gemspec
-
-lib/win32/file.rb
-
-test/sometestfile.txt
-test/tc_file_attributes.rb
-test/tc_file_constants.rb
-test/tc_file_encryption.rb
-test/tc_file_path.rb
-test/tc_file_security.rb
-test/tc_file_stat.rb
-test/ts_all.rb
+* CHANGES
+* MANIFEST
+* Rakefile
+* README
+* install.rb
+* win32-file.gemspec
+* lib/win32/file.rb
+* test/sometestfile.txt
+* test/tc_file_attributes.rb
+* test/tc_file_constants.rb
+* test/tc_file_encryption.rb
+* test/tc_file_path.rb
+* test/tc_file_security.rb
+* test/tc_file_stat.rb
+* test/ts_all.rb

data/README

@@ -2,27 +2,23 @@
 Extra or redefined methods for the File class on MS Windows.
 
 = Prerequisites
-Ruby 1.8.0 or later
-windows-pr 0.3.0 or later
-win32-file-stat 1.2.0 or later
+* Ruby 1.8.0 or later
+* windows-pr 0.3.0 or later
+* win32-file-stat 1.2.0 or later
 
 = Installation
-== Manual install
-ruby test/ts_all.rb # optional
-ruby install.rb
-== Gem Install
-ruby win32-file.gemspec
-gem install win32-file-X.Y.Z-mswin32.gem
+   rake test (optional)
+   rake install (standard) or rake install_gem (rubygems)
 
 = Synopsis
-require 'win32/file'
+   require 'win32/file'
 
-p File.hidden?(somefile)
-p File.attributes(somefile)
+   p File.hidden?(somefile)
+   p File.attributes(somefile)
 
-File.open(somefile){ |fh|
-   fh.hidden = true
-}
+   File.open(somefile){ |fh|
+      fh.hidden = true
+   }
 
 = Class methods added - see documentation for details
 * File.attributes
@@ -94,5 +90,5 @@ implied warranties, including, without limitation, the implied
 warranties of merchantability and fitness for a particular purpose.
 
 = Authors
-Daniel J. Berger
-Park Heesob
+* Daniel J. Berger
+* Park Heesob

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'rake/testtask'
+
+task :clean do 
+   rm 'sometestfile.txt' if File.exists? 'sometestfile.txt'
+end
+
+desc 'Install the win32-file package (non-gem)'
+task :install => [:clean] do
+   ruby 'install.rb'
+end
+
+desc 'Install the win32-file package as a gem'
+task :install_gem => [:clean] do
+   ruby 'win32-file.gemspec'
+   file = Dir['win32-file*.gem'].first
+   sh "gem install #{file}"
+end
+
+Rake::TestTask.new("test") do |t|
+   t.libs << 'test'
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/ts_all.rb']
+end
+
+Rake::TestTask.new("test_attributes") do |t|
+   cp('test/sometestfile.txt', '.')
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/tc_file_attributes.rb']
+end
+
+Rake::TestTask.new("test_constants") do |t|
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/tc_file_constants.rb']
+end
+
+Rake::TestTask.new("test_encryption") do |t|
+   cp('test/sometestfile.txt', '.')
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/tc_file_encryption.rb']
+end
+
+Rake::TestTask.new("test_path") do |t|
+   cp('test/sometestfile.txt', '.')
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/tc_file_path.rb']
+end
+
+Rake::TestTask.new("test_security") do |t|
+   cp('test/sometestfile.txt', '.')
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/tc_file_security.rb']
+end
+
+Rake::TestTask.new("test_stat") do |t|
+   cp('test/sometestfile.txt', '.')
+   t.verbose = true
+   t.warning = true
+   t.test_files = FileList['test/tc_file_stat.rb']
+end

data/lib/win32/file.rb

@@ -14,8 +14,9 @@ class File
    extend Windows::Path
    extend Windows::Security
    extend Windows::MSVCRT::Buffer
+   extend Windows::Limits
    
-   VERSION  = '0.5.3'
+   VERSION  = '0.5.4'
    MAX_PATH = 260
 
    # Abbreviated attribute constants for convenience
@@ -48,510 +49,529 @@ class File
    }
 
    ### Class Methods
-   
-   ## Security
-   
-   # Sets the file permissions for the given file name.  The 'permissions'
-   # argument is a hash with an account name as the key, and the various
-   # permission constants as possible values.  The possible constant values
-   # are:
-   #
-   # FILE_READ_DATA
-   # FILE_WRITE_DATA
-   # FILE_APPEND_DATA
-   # FILE_READ_EA
-   # FILE_WRITE_EA
-   # FILE_EXECUTE
-   # FILE_DELETE_CHILD
-   # FILE_READ_ATTRIBUTES
-   # FILE_WRITE_ATTRIBUTES
-   # STANDARD_RIGHTS_ALL
-   # FULL
-   # READ
-   # ADD
-   # CHANGE
-   # DELETE
-   # READ_CONTROL
-   # WRITE_DAC
-   # WRITE_OWNER
-   # SYNCHRONIZE
-   # STANDARD_RIGHTS_REQUIRED
-   # STANDARD_RIGHTS_READ
-   # STANDARD_RIGHTS_WRITE
-   # STANDARD_RIGHTS_EXECUTE
-   # STANDARD_RIGHTS_ALL
-   # SPECIFIC_RIGHTS_ALL
-   # ACCESS_SYSTEM_SECURITY
-   # MAXIMUM_ALLOWED
-   # GENERIC_READ
-   # GENERIC_WRITE
-   # GENERIC_EXECUTE
-   # GENERIC_ALL
-   #
-   def self.set_permissions(file, perms)
-      raise TypeError unless perms.kind_of?(Hash)
-
-      account_rights = 0
-      sec_desc = 0.chr * SECURITY_DESCRIPTOR_MIN_LENGTH
-
-      unless InitializeSecurityDescriptor(sec_desc, 1)
-         raise ArgumentError, get_last_error
-      end
-
-      cb_acl = 1024
-      cb_sid = 1024
-
-      acl_new = 0.chr * cb_acl
-
-      unless InitializeAcl(acl_new, cb_acl, ACL_REVISION2)
-         raise ArgumentError, get_last_error
-      end
-
-      sid      = 0.chr * cb_sid
-      snu_type = 0.chr * cb_sid
-
-      all_ace = 0.chr * ALLOW_ACE_LENGTH
-      all_ace_ptr = memset(all_ace, 0, 0) # address of all_ace
 
-      # all_ace_ptr->Header.AceType = ACCESS_ALLOWED_ACE_TYPE
-      all_ace[0] = 0
-
-      perms.each{ |account, mask|
-         next if mask.nil?
-        
-         cch_domain = [80].pack('L')
-         cb_sid     = [1024].pack('L')
-         domain_buf = 0.chr * 80
-
-         server, account = account.split("\\")
-
-         if ['BUILTIN', 'NT AUTHORITY'].include?(server.upcase)
-            server = nil
+   class << self
+      # Strictly for making this code -w clean. They are removed later.
+      alias basename_orig basename
+      alias blockdev_orig blockdev?
+      alias chardev_orig chardev?
+      alias dirname_orig dirname
+      alias lstat_orig lstat
+      alias size_orig size
+      alias split_orig split
+      alias stat_orig stat
+
+      ## Security
+      
+      # Sets the file permissions for the given file name.  The 'permissions'
+      # argument is a hash with an account name as the key, and the various
+      # permission constants as possible values.  The possible constant values
+      # are:
+      #
+      # FILE_READ_DATA
+      # FILE_WRITE_DATA
+      # FILE_APPEND_DATA
+      # FILE_READ_EA
+      # FILE_WRITE_EA
+      # FILE_EXECUTE
+      # FILE_DELETE_CHILD
+      # FILE_READ_ATTRIBUTES
+      # FILE_WRITE_ATTRIBUTES
+      # STANDARD_RIGHTS_ALL
+      # FULL
+      # READ
+      # ADD
+      # CHANGE
+      # DELETE
+      # READ_CONTROL
+      # WRITE_DAC
+      # WRITE_OWNER
+      # SYNCHRONIZE
+      # STANDARD_RIGHTS_REQUIRED
+      # STANDARD_RIGHTS_READ
+      # STANDARD_RIGHTS_WRITE
+      # STANDARD_RIGHTS_EXECUTE
+      # STANDARD_RIGHTS_ALL
+      # SPECIFIC_RIGHTS_ALL
+      # ACCESS_SYSTEM_SECURITY
+      # MAXIMUM_ALLOWED
+      # GENERIC_READ
+      # GENERIC_WRITE
+      # GENERIC_EXECUTE
+      # GENERIC_ALL
+      #
+      def set_permissions(file, perms)
+         raise TypeError unless perms.kind_of?(Hash)
+
+         account_rights = 0
+         sec_desc = 0.chr * SECURITY_DESCRIPTOR_MIN_LENGTH
+
+         unless InitializeSecurityDescriptor(sec_desc, 1)
+            raise ArgumentError, get_last_error
          end
 
-         val = LookupAccountName(
-            server,
-            account,
-            sid,
-            cb_sid,
-            domain_buf,
-            cch_domain,
-            snu_type
-         )
+         cb_acl = 1024
+         cb_sid = 1024
 
-         if val == 0
+         acl_new = 0.chr * cb_acl
+
+         unless InitializeAcl(acl_new, cb_acl, ACL_REVISION2)
             raise ArgumentError, get_last_error
          end
 
-         size = [0,0,0,0,0].pack('CCSLL').length # sizeof(ACCESS_ALLOWED_ACE)
-         
-         val = CopySid(
-            ALLOW_ACE_LENGTH - size,
-            all_ace_ptr + 8,  # address of all_ace_ptr->SidStart
-            sid
-         )
+         sid      = 0.chr * cb_sid
+         snu_type = 0.chr * cb_sid
 
-         if val == 0
-            raise ArgumentError, get_last_error
-         end
+         all_ace = 0.chr * ALLOW_ACE_LENGTH
+         all_ace_ptr = memset(all_ace, 0, 0) # address of all_ace
 
-         if (GENERIC_ALL & mask).nonzero?
-            account_rights = GENERIC_ALL & mask
-         elsif (GENERIC_RIGHTS_CHK & mask).nonzero?
-            account_rights = GENERIC_RIGHTS_MASK & mask
-         end
+         # all_ace_ptr->Header.AceType = ACCESS_ALLOWED_ACE_TYPE
+         all_ace[0] = 0
 
-         # all_ace_ptr->Header.AceFlags = INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE;
-         all_ace[1] = INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE
+         perms.each{ |account, mask|
+            next if mask.nil?
+           
+            cch_domain = [80].pack('L')
+            cb_sid     = [1024].pack('L')
+            domain_buf = 0.chr * 80
 
-         2.times{
-            if account_rights != 0
-               all_ace[2,2] = [12 - 4 + GetLengthSid(sid)].pack('S')
-               all_ace[4,4] = [account_rights].pack('L')
+            server, account = account.split("\\")
 
-               val = AddAce(
-                  acl_new,
-                  ACL_REVISION2,
-                  MAXDWORD,
-                  all_ace_ptr,
-                  all_ace[2,2].unpack('S').first
-               )
+            if ['BUILTIN', 'NT AUTHORITY'].include?(server.upcase)
+               server = nil
+            end
 
-               if val == 0
-                  raise ArgumentError, get_last_error
-               end
+            val = LookupAccountName(
+               server,
+               account,
+               sid,
+               cb_sid,
+               domain_buf,
+               cch_domain,
+               snu_type
+            )
 
-               # all_ace_ptr->Header.AceFlags = CONTAINER_INHERIT_ACE
-               all_ace[1] = CONTAINER_INHERIT_ACE
-            else
-               # all_ace_ptr->Header.AceFlags = 0
-               all_ace[1] = 0
+            if val == 0
+               raise ArgumentError, get_last_error
             end
 
-            account_rights = REST_RIGHTS_MASK & mask
-         }
-      }
+            size = [0,0,0,0,0].pack('CCSLL').length # sizeof(ACCESS_ALLOWED_ACE)
+            
+            val = CopySid(
+               ALLOW_ACE_LENGTH - size,
+               all_ace_ptr + 8,  # address of all_ace_ptr->SidStart
+               sid
+            )
 
-      unless SetSecurityDescriptorDacl(sec_desc, 1, acl_new, 0)
-         raise ArgumentError, get_last_error
-      end
+            if val == 0
+               raise ArgumentError, get_last_error
+            end
 
-      unless SetFileSecurity(file, DACL_SECURITY_INFORMATION, sec_desc)
-         raise ArgumentError, get_last_error
-      end
+            if (GENERIC_ALL & mask).nonzero?
+               account_rights = GENERIC_ALL & mask
+            elsif (GENERIC_RIGHTS_CHK & mask).nonzero?
+               account_rights = GENERIC_RIGHTS_MASK & mask
+            end
 
-      self
-   end
-   
-   # Returns an array of human-readable strings that correspond to the
-   # permission flags.
-   #
-   def self.securities(mask)
-      sec_array = []
-      if mask == 0
-         sec_array.push('NONE')
-      else
-         if (mask & FULL) ^ FULL == 0
-            sec_array.push('FULL')
-         else
-            SECURITY_RIGHTS.each{ |string, numeric|
-               if (numeric & mask) ^ numeric == 0
-                  sec_array.push(string)
+            # all_ace_ptr->Header.AceFlags = INHERIT_ONLY_ACE|OBJECT_INHERIT_ACE
+            all_ace[1] = INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE
+
+            2.times{
+               if account_rights != 0
+                  all_ace[2,2] = [12 - 4 + GetLengthSid(sid)].pack('S')
+                  all_ace[4,4] = [account_rights].pack('L')
+
+                  val = AddAce(
+                     acl_new,
+                     ACL_REVISION2,
+                     MAXDWORD,
+                     all_ace_ptr,
+                     all_ace[2,2].unpack('S').first
+                  )
+
+                  if val == 0
+                     raise ArgumentError, get_last_error
+                  end
+
+                  # all_ace_ptr->Header.AceFlags = CONTAINER_INHERIT_ACE
+                  all_ace[1] = CONTAINER_INHERIT_ACE
+               else
+                  # all_ace_ptr->Header.AceFlags = 0
+                  all_ace[1] = 0
                end
+
+               account_rights = REST_RIGHTS_MASK & mask
             }
-         end
-      end
-      sec_array
-   end
+         }
 
-   # Returns a hash describing the current file permissions for the given file.
-   # The account name is the key, and the value is an integer representing
-   # an or'd value that corresponds to the security permissions for that file.
-	#
-   # To get a human readable version of the permissions, pass the value to the
-   # +File.securities+ method.
-   #
-   def self.get_permissions(file, host=nil)
-      current_length = 0
-      length_needed  = [0].pack('L')
-      sec_buf = ''
-
-      loop do
-         bool = GetFileSecurity(
-            file,
-            DACL_SECURITY_INFORMATION,
-            sec_buf,
-            sec_buf.length,
-            length_needed
-         )
+         unless SetSecurityDescriptorDacl(sec_desc, 1, acl_new, 0)
+            raise ArgumentError, get_last_error
+         end
 
-         if bool == 0 && GetLastError() != ERROR_INSUFFICIENT_BUFFER
+         unless SetFileSecurity(file, DACL_SECURITY_INFORMATION, sec_desc)
             raise ArgumentError, get_last_error
          end
-         
-         break if sec_buf.length >= length_needed.unpack('L').first
-         sec_buf += ' ' * length_needed.unpack('L').first
+
+         self
+      end
+      
+      # Returns an array of human-readable strings that correspond to the
+      # permission flags.
+      #
+      def securities(mask)
+         sec_array = []
+         if mask == 0
+            sec_array.push('NONE')
+         else
+            if (mask & FULL) ^ FULL == 0
+               sec_array.push('FULL')
+            else
+               SECURITY_RIGHTS.each{ |string, numeric|
+                  if (numeric & mask) ^ numeric == 0
+                     sec_array.push(string)
+                  end
+               }
+            end
+         end
+         sec_array
       end
 
-      control  = [0].pack('L')
-      revision = [0].pack('L')
+      # Returns a hash describing the current file permissions for the given
+      # file.  The account name is the key, and the value is an integer
+      # representing an or'd value that corresponds to the security
+      # permissions for that file.
+      #
+      # To get a human readable version of the permissions, pass the value to
+      # the +File.securities+ method.
+      #
+      def get_permissions(file, host=nil)
+         current_length = 0
+         length_needed  = [0].pack('L')
+         sec_buf = ''
+
+         loop do
+            bool = GetFileSecurity(
+               file,
+               DACL_SECURITY_INFORMATION,
+               sec_buf,
+               sec_buf.length,
+               length_needed
+            )
 
-      unless GetSecurityDescriptorControl(sec_buf, control, revision)
-         raise ArgumentError, get_last_error
-      end
+            if bool == 0 && GetLastError() != ERROR_INSUFFICIENT_BUFFER
+               raise ArgumentError, get_last_error
+            end
+            
+            break if sec_buf.length >= length_needed.unpack('L').first
+            sec_buf += ' ' * length_needed.unpack('L').first
+         end
 
-      # No DACL exists
-      if (control.unpack('L').first & SE_DACL_PRESENT) == 0
-         raise ArgumentError, 'No DACL present: explicit deny all'
-      end
+         control  = [0].pack('L')
+         revision = [0].pack('L')
 
-      dacl_present   = [0].pack('L')
-      dacl_defaulted = [0].pack('L')
-      dacl_ptr       = [0].pack('L')
+         unless GetSecurityDescriptorControl(sec_buf, control, revision)
+            raise ArgumentError, get_last_error
+         end
 
-      val = GetSecurityDescriptorDacl(
-         sec_buf,
-         dacl_present,
-         dacl_ptr,
-         dacl_defaulted
-      )
+         # No DACL exists
+         if (control.unpack('L').first & SE_DACL_PRESENT) == 0
+            raise ArgumentError, 'No DACL present: explicit deny all'
+         end
 
-      if val == 0
-         raise ArgumentError, get_last_error
-      end
+         dacl_present   = [0].pack('L')
+         dacl_defaulted = [0].pack('L')
+         dacl_ptr       = [0].pack('L')
 
-      acl_buf = 0.chr * 8 # byte, byte, word, word, word (struct ACL)
-      memcpy(acl_buf, dacl_ptr.unpack('L').first, acl_buf.size)
+         val = GetSecurityDescriptorDacl(
+            sec_buf,
+            dacl_present,
+            dacl_ptr,
+            dacl_defaulted
+         )
 
-      if acl_buf.unpack('CCSSS').first == 0
-         raise ArgumentError, 'DACL is NULL: implicit access grant'
-      end
+         if val == 0
+            raise ArgumentError, get_last_error
+         end
 
-      ace_ptr   = [0].pack('L')
-      ace_count = acl_buf.unpack('CCSSS')[3]
+         acl_buf = 0.chr * 8 # byte, byte, word, word, word (struct ACL)
+         memcpy(acl_buf, dacl_ptr.unpack('L').first, acl_buf.size)
 
-      perms_hash = {}
-      0.upto(ace_count - 1){ |i|
-         unless GetAce(dacl_ptr.unpack('L').first, i, ace_ptr)
-            next
+         if acl_buf.unpack('CCSSS').first == 0
+            raise ArgumentError, 'DACL is NULL: implicit access grant'
          end
 
-         ace_buf = 0.chr * 12 # ACE_HEADER, dword, dword (ACCESS_ALLOWED_ACE) 
-         memcpy(ace_buf, ace_ptr.unpack('L').first, ace_buf.size)
+         ace_ptr   = [0].pack('L')
+         ace_count = acl_buf.unpack('CCSSS')[3]
 
-         if ace_buf.unpack('CCS').first == ACCESS_ALLOWED_ACE_TYPE
-            name        = 0.chr * MAX_PATH
-            name_size   = [name.size].pack('L')
-            domain      = 0.chr * MAX_PATH
-            domain_size = [domain.size].pack('L')
-            snu_ptr     = 0.chr * 4
-            
-            val = LookupAccountSid(
-               host,
-               ace_ptr.unpack('L').first + 8, # address of ace_ptr->SidStart
-               name,
-               name_size,
-               domain,
-               domain_size,
-               snu_ptr
-            )
-            
-            if val == 0
-               raise ArgumentError, get_last_error
+         perms_hash = {}
+         0.upto(ace_count - 1){ |i|
+            unless GetAce(dacl_ptr.unpack('L').first, i, ace_ptr)
+               next
             end
-            
-            name   = name[0..name_size.unpack('L').first].split(0.chr)[0]
-            domain = domain[0..domain_size.unpack('L').first].split(0.chr)[0]
-            mask   = ace_buf.unpack('LLL')[1]
-            
-            unless domain.nil? || domain.empty?
-               name = domain + '\\' + name
+
+            ace_buf = 0.chr * 12 # ACE_HEADER, dword, dword (ACCESS_ALLOWED_ACE)
+            memcpy(ace_buf, ace_ptr.unpack('L').first, ace_buf.size)
+
+            if ace_buf.unpack('CCS').first == ACCESS_ALLOWED_ACE_TYPE
+               name        = 0.chr * MAX_PATH
+               name_size   = [name.size].pack('L')
+               domain      = 0.chr * MAX_PATH
+               domain_size = [domain.size].pack('L')
+               snu_ptr     = 0.chr * 4
+               
+               val = LookupAccountSid(
+                  host,
+                  ace_ptr.unpack('L').first + 8, # address of ace_ptr->SidStart
+                  name,
+                  name_size,
+                  domain,
+                  domain_size,
+                  snu_ptr
+               )
+               
+               if val == 0
+                  raise ArgumentError, get_last_error
+               end
+               
+               name   = name[0..name_size.unpack('L').first].split(0.chr)[0]
+               domain = domain[0..domain_size.unpack('L').first].split(0.chr)[0]
+               mask   = ace_buf.unpack('LLL')[1]
+               
+               unless domain.nil? || domain.empty?
+                  name = domain + '\\' + name
+               end
+               
+               perms_hash[name] = mask
             end
-            
-            perms_hash[name] = mask
+         }
+         perms_hash
+      end
+      
+      ## Encryption
+      
+      # Encrypts a file or directory. All data streams in a file are encrypted.
+      # All new files created in an encrypted directory are encrypted.
+      #
+      # The caller must have the FILE_READ_DATA, FILE_WRITE_DATA,
+      # FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, and SYNCHRONIZE access
+      # rights.
+      # 
+      # Requires exclusive access to the file being encrypted, and will fail if
+      # another process is using the file.  If the file is compressed,
+      # EncryptFile will decompress the file before encrypting it.
+      # 
+      # Windows 2000 or later only.
+      #
+      def encrypt(file)
+         unless EncryptFile(file)
+            raise ArgumentError, get_last_error
          end
-      }
-      perms_hash
-   end
-   
-   ## Encryption
-   
-   # Encrypts a file or directory. All data streams in a file are encrypted.
-   # All new files created in an encrypted directory are encrypted.
-   #
-   # The caller must have the FILE_READ_DATA, FILE_WRITE_DATA,
-   # FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, and SYNCHRONIZE access
-   # rights.
-   # 
-   # Requires exclusive access to the file being encrypted, and will fail if
-   # another process is using the file.  If the file is compressed, EncryptFile
-   # will decompress the file before encrypting it.
-   # 
-   # Windows 2000 or later only.
-   #
-   def self.encrypt(file)
-      unless EncryptFile(file)
-         raise ArgumentError, get_last_error
+         self
       end
-      self
-   end
-   
-   # Decrypts an encrypted file or directory.
-   #  
-   # The caller must have the FILE_READ_DATA, FILE_WRITE_DATA,
-   # FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, and SYNCHRONIZE access
-   # rights.
-   # 
-   # Requires exclusive access to the file being decrypted, and will fail if
-   # another process is using the file. If the file is not encrypted an error
-   # is NOT raised.
-   # 
-   # Windows 2000 or later only.
-   #
-   def self.decrypt(file)
-      unless DecryptFile(file, 0)
-         raise ArgumentError, get_last_error
+      
+      # Decrypts an encrypted file or directory.
+      #  
+      # The caller must have the FILE_READ_DATA, FILE_WRITE_DATA,
+      # FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, and SYNCHRONIZE access
+      # rights.
+      # 
+      # Requires exclusive access to the file being decrypted, and will fail if
+      # another process is using the file. If the file is not encrypted an error
+      # is NOT raised.
+      # 
+      # Windows 2000 or later only.
+      #
+      def decrypt(file)
+         unless DecryptFile(file, 0)
+            raise ArgumentError, get_last_error
+         end
+         self
       end
-      self
-   end
 
-   ## Path methods
-   
-   # Returns the last component of the filename given in +filename+.  If
-   # +suffix+ is given and present at the end of +filename+, it is removed.
-   # Any extension can be removed by giving an extension of ".*".
-   #
-   # This was reimplemented because the current version does not handle UNC
-   # paths properly, i.e. it should not return anything less than the root.
-   # In all other respects it is identical to the current implementation.
-   #
-   # File.basename("C:\\foo\\bar.txt")         -> "bar.txt"
-   # File.basename("C:\\foo\\bar.txt", ".txt") -> "bar"
-   # File.basename("\\\\foo\\bar")             -> "\\\\foo\\bar"
-   #
-   def self.basename(file, suffix = nil)
-      fpath = false
-      file = file.dup # Don't modify original string
+      ## Path methods
       
-      # We have to convert forward slashes to backslashes for the Windows
-      # functions to work properly.
-      if file.include?('/')
-         file.tr!('/', '\\')
-         fpath = true
+      # Returns the last component of the filename given in +filename+.  If
+      # +suffix+ is given and present at the end of +filename+, it is removed.
+      # Any extension can be removed by giving an extension of ".*".
+      #
+      # This was reimplemented because the current version does not handle UNC
+      # paths properly, i.e. it should not return anything less than the root.
+      # In all other respects it is identical to the current implementation.
+      #
+      # File.basename("C:\\foo\\bar.txt")         -> "bar.txt"
+      # File.basename("C:\\foo\\bar.txt", ".txt") -> "bar"
+      # File.basename("\\\\foo\\bar")             -> "\\\\foo\\bar"
+      #
+      def basename(file, suffix = nil)
+         fpath = false
+         file = file.dup # Don't modify original string
+         
+         # We have to convert forward slashes to backslashes for the Windows
+         # functions to work properly.
+         if file.include?('/')
+            file.tr!('/', '\\')
+            fpath = true
+         end
+             
+         # Return an empty or root path as-is.
+         if file.empty? || PathIsRoot(file)
+            file.tr!("\\", '/') if fpath
+            return file
+         end
+         
+         PathStripPath(file) # Gives us the basename
+         
+         if suffix
+            if suffix == '.*'
+               PathRemoveExtension(file)
+            else
+               if PathFindExtension(file) == suffix
+                  PathRemoveExtension(file)
+               end
+            end
+         end
+         
+         file = file.split(0.chr).first
+         
+         # Trim trailing slashes
+         while file[-1].chr == "\\"
+            file.chop!
+         end
+         
+         # Return forward slashes if that's how the path was passed in.
+         if fpath
+            file.tr!("\\", '/')
+         end
+         
+         file
       end
-          
-      # Return an empty or root path as-is.
-      if file.empty? || PathIsRoot(file)
+
+      # Returns all components of the filename given in +filename+ except the
+      # last one.
+      # 
+      # This was reimplemented because the current version does not handle UNC
+      # paths properly, i.e. it should not return anything less than the root.
+      # In all other respects it is identical to the current implementation.
+      #
+      # File.dirname("C:\\foo\\bar\\baz.txt") -> "C:\\foo\\bar"
+      # File.dirname("\\\\foo\\bar")          -> "\\\\foo\\bar"
+      #
+      def dirname(file)
+         fpath = false
+         file = file.dup
+         
+         if file.include?('/')
+            file.tr!('/', "\\")
+            fpath = true
+         end
+         
+         if PathIsRelative(file)
+            return '.'
+         end
+         
+         if PathIsRoot(file)
+            file.tr!("\\", '/') if fpath
+            return file
+         end
+         
+         PathRemoveFileSpec(file)
+         file = file.split(0.chr).first
+         PathRemoveBackslash(file)
+         
          file.tr!("\\", '/') if fpath
-         return file
+         file
       end
-      
-      PathStripPath(file) # Gives us the basename
-      
-      if suffix
-         if suffix == '.*'
-            PathRemoveExtension(file)
-         else
-            if PathFindExtension(file) == suffix
-               PathRemoveExtension(file)
-            end
+
+      # Returns +file+ in long format. For example, if 'SOMEFI~1.TXT'
+      # was the argument provided, and the short representation for
+      # 'somefile.txt', then this method would return 'somefile.txt'.
+      #
+      # Note that certain file system optimizations may prevent this method
+      # from working as expected.  In that case, you will get back the file
+      # name in 8.3 format.
+      #
+      def long_path(file)
+         buf = 0.chr * MAX_PATH
+         if GetLongPathName(file, buf, buf.size) == 0
+            raise ArgumentError, get_last_error
          end
+         File.basename(buf.split(0.chr).first.strip)
       end
-      
-      file = file.split(0.chr).first
-      
-      # Trim trailing slashes
-      while file[-1].chr == "\\"
-         file.chop!
+
+      # Returns 'file_name' in 8.3 format. For example, 'c:\documentation.doc'
+      # would be returned as 'c:\docume~1.doc'.
+      #
+      def short_path(file)
+         buf = 0.chr * MAX_PATH
+         if GetShortPathName(file, buf, buf.size) == 0
+            raise ArgumentError, get_last_error
+         end
+         File.basename(buf.split(0.chr).first.strip)
       end
-      
-      # Return forward slashes if that's how the path was passed in.
-      if fpath
-         file.tr!("\\", '/')
+
+      # Splits the given string into a directory and a file component and
+      # returns them in a two element array.  This was reimplemented because
+      # the current version does not handle UNC paths properly.
+      # 
+      def split(file)
+         array = []
+         
+         if file.empty? || PathIsRoot(file)
+            array.push(file, '')
+         else
+            array.push(File.dirname(file), File.basename(file))
+         end
+         array
       end
-      
-      file
-   end
 
-   # Returns all components of the filename given in +filename+ except the
-   # last one.
-   # 
-   # This was reimplemented because the current version does not handle UNC
-   # paths properly, i.e. it should not return anything less than the root.
-   # In all other respects it is identical to the current implementation.
-   #
-   # File.dirname("C:\\foo\\bar\\baz.txt") -> "C:\\foo\\bar"
-   # File.dirname("\\\\foo\\bar")          -> "\\\\foo\\bar"
-   #
-   def self.dirname(file)
-      fpath = false
-      file = file.dup
+      ## Stat methods
       
-      if file.include?('/')
-         file.tr!('/', "\\")
-         fpath = true
+      # Returns a File::Stat object, as defined in the win32-file-stat package.
+      # 
+      def stat(file)
+         File::Stat.new(file)
       end
       
-      if PathIsRelative(file)
-         return '.'
+      # Identical to File.stat on Windows.
+      # 
+      def lstat(file)
+         File::Stat.new(file)
       end
       
-      if PathIsRoot(file)
-         file.tr!("\\", '/') if fpath
-         return file
+      # Returns the file system's block size.
+      #
+      def blksize(file)
+         File::Stat.new(file).blksize
       end
-      
-      PathRemoveFileSpec(file)
-      file = file.split(0.chr).first
-      PathRemoveBackslash(file)
-      
-      file.tr!("\\", '/') if fpath
-      file
-   end
 
-   # Returns +file+ in long format. For example, if 'SOMEFI~1.TXT'
-   # was the argument provided, and the short representation for
-   # 'somefile.txt', then this method would return 'somefile.txt'.
-   #
-   # Note that certain file system optimizations may prevent this method
-   # from working as expected.  In that case, you will get back the file
-   # name in 8.3 format.
-   #
-   def self.long_path(file)
-      buf = 0.chr * MAX_PATH
-      if GetLongPathName(file, buf, buf.size) == 0
-         raise ArgumentError, get_last_error
+      # Returns whether or not +file+ is a block device. For MS Windows this
+      # means a removable drive, cdrom or ramdisk.
+      #
+      def blockdev?(file)
+         File::Stat.new(file).blockdev?
       end
-      File.basename(buf.split(0.chr).first.strip)
-   end
 
-   # Returns 'file_name' in 8.3 format. For example, 'c:\documentation.doc'
-   # would be returned as 'c:\docume~1.doc'.
-   #
-   def self.short_path(file)
-      buf = 0.chr * MAX_PATH
-      if GetShortPathName(file, buf, buf.size) == 0
-         raise ArgumentError, get_last_error
+      # Returns true if the file is a character device.  This replaces the
+      # current Ruby implementation which always returns false.
+      #
+      def chardev?(file)
+         File::Stat.new(file).chardev?
       end
-      File.basename(buf.split(0.chr).first.strip)
-   end
 
-   # Splits the given string into a directory and a file component and returns
-   # them in a two element array.  This was reimplemented because the
-   # current version does not handle UNC paths properly.
-   # 
-   def self.split(file)
-      array = []
-      
-      if file.empty? || PathIsRoot(file)
-         array.push(file, '')
-      else
-         array.push(File.dirname(file), File.basename(file))
+      # Returns the size of the file in bytes.
+      #
+      # This was reimplemented because the current version does not handle file
+      # sizes greater than 2gb.
+      #
+      def size(file)
+         File::Stat.new(file).size
       end
-      array
-   end
-
-   ## Stat methods
-   
-   # Returns a File::Stat object, as defined in the win32-file-stat package.
-   # 
-   def self.stat(file)
-      File::Stat.new(file)
-   end
-   
-   # Identical to File.stat on Windows.
-   # 
-   def self.lstat(file)
-      File::Stat.new(file)
-   end
-   
-   # Returns the file system's block size.
-   #
-   def self.blksize(file)
-      File::Stat.new(file).blksize
-   end
-
-   # Returns whether or not +file+ is a block device.
-   #
-   def self.blockdev?(file)
-      File::Stat.new(file).blockdev?
-   end
-
-   # Returns true if the file is a character device.  This replaces the current
-   # Ruby implementation which always returns false.
-   #
-   def self.chardev?(file)
-      File::Stat.new(file).chardev?
-   end
 
-   # Returns the size of the file in bytes.
-   #
-   # This was reimplemented because the current version does not handle file
-   # sizes greater than 2gb.
-   #
-   def self.size(file)
-      File::Stat.new(file).size
-   end
+      # We no longer need the aliases, so remove them
+      remove_method(:basename_orig, :blockdev_orig, :chardev_orig)
+      remove_method(:dirname_orig, :lstat_orig, :size_orig)
+      remove_method(:split_orig, :stat_orig)
+   end # class << self
 
    ## Attribute methods
 
@@ -923,7 +943,7 @@ class File
    #
    def sparse=(bool)     
       unless bool
-         warn 'Cannot remove sparse property from a file - operation ignored'
+         warn 'cannot remove sparse property from a file - operation ignored'
          return
       end
       
@@ -1019,19 +1039,4 @@ class File
       alias :set_attr :set_attributes
       alias :unset_attr :remove_attributes
    end
-   
-   private
-   
-   # This is based on the CTL_CODE macro in WinIoCtl.h
-   def CTL_CODE(device, function, method, access)
-      ((device) << 16) | ((access) << 14) | ((function) << 2) | (method)
-   end
-   
-   def FSCTL_SET_COMPRESSION 
-      CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 16, 0, FILE_READ_DATA | FILE_WRITE_DATA)
-   end
-   
-   def FSCTL_SET_SPARSE
-      CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 49, 0, FILE_SPECIAL_ACCESS)
-   end
 end