win32-file 0.6.9 → 0.7.0

data/lib/win32/file/constants.rb

@@ -0,0 +1,27 @@
+require 'ffi'
+
+module Windows
+  module File
+    module Constants
+      FILE_ATTRIBUTE_NORMAL = 0x00000080
+      FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400
+      FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
+      FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
+      FILE_SHARE_READ = 1
+
+      FILE_TYPE_UNKNOWN = 0x0000
+      FILE_TYPE_CHAR    = 0x0002
+      NO_ERROR = 0
+
+      GENERIC_READ = 0x80000000
+      INVALID_HANDLE_VALUE = (1 << FFI::Platform::ADDRESS_SIZE) - 1
+      INVALID_FILE_ATTRIBUTES = (1 << FFI::Platform::ADDRESS_SIZE) - 1
+      IO_REPARSE_TAG_SYMLINK = 0xA000000C
+      OPEN_EXISTING = 3
+
+      DRIVE_REMOVABLE = 2
+      DRIVE_CDROM     = 5
+      DRIVE_RAMDISK   = 6
+    end
+  end
+end

data/lib/win32/file/functions.rb

@@ -0,0 +1,49 @@
+module Windows
+  module File
+    module Functions
+      extend FFI::Library
+      ffi_lib :kernel32
+
+      typedef :ulong, :dword
+      typedef :uintptr_t, :handle
+      typedef :pointer, :ptr
+
+      def self.attach_pfunc(*args)
+        attach_function(*args)
+        private args[0]
+      end
+
+      attach_pfunc :CloseHandle, [:handle], :bool
+      attach_pfunc :CreateFileW, [:buffer_in, :dword, :dword, :pointer, :dword, :dword, :handle], :handle
+      attach_pfunc :CreateSymbolicLinkW, [:buffer_in, :buffer_in, :dword], :bool
+      attach_pfunc :FindFirstFileW, [:buffer_in, :pointer], :handle
+      attach_pfunc :GetDiskFreeSpaceW, [:buffer_in, :pointer, :pointer, :pointer, :pointer], :bool
+      attach_pfunc :GetDriveTypeW, [:buffer_in], :uint
+      attach_pfunc :GetFileType, [:handle], :dword
+      attach_pfunc :GetFileAttributesW, [:buffer_in], :dword
+      attach_pfunc :GetFinalPathNameByHandleW, [:handle, :buffer_out, :dword, :dword], :dword
+      attach_pfunc :GetShortPathNameW, [:buffer_in, :buffer_out, :dword], :dword
+      attach_pfunc :GetLongPathNameW, [:buffer_in, :buffer_out, :dword], :dword
+      attach_pfunc :QueryDosDeviceA, [:string, :buffer_out, :dword], :dword
+
+      ffi_lib :shlwapi
+
+      attach_pfunc :PathFindExtensionW, [:buffer_in], :pointer
+      attach_pfunc :PathIsRootW, [:buffer_in], :bool
+      attach_pfunc :PathStripPathW, [:pointer], :void
+      attach_pfunc :PathRemoveBackslashW, [:buffer_in], :string
+      attach_pfunc :PathRemoveFileSpecW, [:pointer], :bool
+      attach_pfunc :PathRemoveExtensionW, [:buffer_in], :void
+      attach_pfunc :PathStripToRootW, [:buffer_in], :bool
+    end
+  end
+end
+
+class String
+  # Read a wide character string up until the first double null, and delete
+  # any remaining null characters.
+  def wstrip
+    self.force_encoding('UTF-16LE').encode('UTF-8',:invalid=>:replace,:undef=>:replace).
+    split("\x00")[0].encode(Encoding.default_external)
+  end
+end

data/lib/win32/file/structs.rb

@@ -0,0 +1,24 @@
+module Windows
+  module File
+    module Structs
+      class FILETIME < FFI::Struct
+        layout(:dwLowDateTime, :ulong, :dwHighDateTime, :ulong)
+      end
+
+      class WIN32_FIND_DATA < FFI::Struct
+        layout(
+          :dwFileAttributes, :ulong,
+          :ftCreationTime, FILETIME,
+          :ftLastAccessTime, FILETIME,
+          :ftLastWriteTime, FILETIME,
+          :nFileSizeHigh, :ulong,
+          :nFileSizeLow, :ulong,
+          :dwReserved0, :ulong,
+          :dwReserved1, :ulong,
+          :cFileName, [:uint8, 260*2],
+          :cAlternateFileName, [:uint8, 14*2]
+        )
+      end
+    end
+  end
+end

data/test/test_win32_file_link.rb

@@ -0,0 +1,141 @@
+#############################################################################
+# test_win32_file_link.rb
+#
+# Test case for the link related methods of win32-file. You should run this
+# test via the 'rake test' or 'rake test:link' task.
+#############################################################################
+require 'test-unit'
+require 'win32/security'
+require 'win32/file'
+
+class TC_Win32_File_Link < Test::Unit::TestCase
+  def self.startup
+    Dir.chdir(File.expand_path(File.dirname(__FILE__)))
+    @@file = File.join(Dir.pwd, 'link_test.txt')
+    File.open(@@file, 'w'){ |fh| fh.puts "This is a link test." }
+  end
+
+  def setup
+    @link  = "this_is_a_symlink"
+    @file  = "link_test.txt"
+    @admin = Win32::Security.elevated_security?
+  end
+
+  test "symlink basic functionality" do
+    assert_respond_to(File, :symlink)
+  end
+
+  test "symlink to a file works as expected" do
+    omit_unless(@admin)
+    assert_nothing_raised{ File.symlink(@@file, @link) }
+    assert_true(File.exists?(@link))
+    assert_true(File.symlink?(@link))
+  end
+
+  test "symlink method returns zero" do
+    omit_unless(@admin)
+    assert_equal(0, File.symlink(@@file, @link))
+  end
+
+  test "symlink requires two arguments" do
+    assert_raise(ArgumentError){ File.symlink }
+    assert_raise(ArgumentError){ File.symlink(@link) }
+    assert_raise(ArgumentError){ File.symlink(@@file, @link, @link) }
+  end
+
+  test "symlink fails if link already exists" do
+    omit_unless(@admin)
+    File.symlink(@@file, @link)
+    assert_raise(SystemCallError){ File.symlink(@@file, @link) }
+  end
+
+  test "symlink does not fail if target does not exist" do
+    omit_unless(@admin)
+    assert_nothing_raised{ File.symlink('bogus.txt', @link) }
+  end
+
+  test "symlink? basic functionality" do
+    assert_respond_to(File, :symlink?)
+    assert_boolean(File.symlink?(@@file))
+  end
+
+  test "symlink? returns expected result" do
+    omit_unless(@admin)
+    File.symlink(@@file, @link)
+    assert_true(File.symlink?(@link))
+    assert_false(File.symlink?(@file))
+  end
+
+  test "symlink? requires one argument only" do
+    assert_raise(ArgumentError){ File.symlink? }
+    assert_raise(ArgumentError){ File.symlink?(@@file, @@file) }
+  end
+
+  test "readlink basic functionality" do
+    assert_respond_to(File, :readlink)
+  end
+
+  test "readlink returns the expected value when reading a symlink" do
+    omit_unless(@admin)
+    File.symlink(@file, @link)
+    expected = File.expand_path(@file).tr("/", "\\")
+    assert_equal(expected, File.readlink(@link))
+  end
+
+  test "readlink raises an error when reading a regular file" do
+    assert_raise(Errno::EINVAL){ File.readlink(@@file) }
+  end
+
+  test "readlink requires one argument only" do
+    assert_raise(ArgumentError){ File.readlink }
+    assert_raise(ArgumentError){ File.readlink(@link, @link) }
+  end
+
+  test "readlink raises an error if the file is not found" do
+    assert_raise(Errno::ENOENT){ File.readlink('bogus.txt') }
+  end
+
+  test "realdirpath basic functionality" do
+    assert_respond_to(File, :realdirpath)
+  end
+
+  test "realdirpath returns the expected value for a regular file" do
+    assert_equal(Dir.pwd, File.realdirpath(Dir.pwd))
+    assert_equal(@@file, File.realdirpath(@@file).tr("/", "\\"))
+  end
+
+  test "realdirpath returns the expected value for a symlink" do
+    omit_unless(@admin)
+    File.symlink(@@file, @link)
+    expected = File.expand_path(@file).tr("/", "\\")
+    assert_equal(expected, File.realdirpath(@link))
+  end
+
+  test "realpath basic functionality" do
+    assert_respond_to(File, :realpath)
+  end
+
+  test "realpath returns the expected value for a regular file" do
+    assert_equal(Dir.pwd, File.realpath(Dir.pwd))
+    assert_equal(@@file, File.realpath(@@file).tr("/", "\\"))
+  end
+
+  test "realpath returns the expected value for a symlink" do
+    omit_unless(@admin)
+    File.symlink(@@file, @link)
+    expected = File.expand_path(@file).tr("/", "\\")
+    assert_equal(expected, File.realpath(@link))
+  end
+
+  def teardown
+    File.delete(@link) rescue nil # Necessary for dangling links
+    @link  = nil
+    @admin = nil
+    @file  = nil
+  end
+
+  def self.shutdown
+    File.delete(@@file) if File.exists?(@@file)
+    @@file = nil
+  end
+end

data/test/test_win32_file_misc.rb

@@ -0,0 +1,16 @@
+########################################################################
+# Miscellaneous tests for win32-file that didn't fit anywhere else.
+########################################################################
+require 'win32/file'
+require 'test-unit'
+
+class TC_Win32_File_Misc < Test::Unit::TestCase
+  test "version constant is set to expected value" do
+    assert_equal('0.7.0', File::WIN32_FILE_VERSION)
+  end
+
+  test "ffi functions are private" do
+    assert_not_respond_to(File, :CloseHandle)
+    assert_not_respond_to(File, :CreateFileW)
+  end
+end

data/test/test_win32_file_path.rb

@@ -2,32 +2,29 @@
 # test_win32_file_path.rb
 #
 # Test case for the path related methods of win32-file. You should run this
-# test via the 'rake test' or 'rake test_path' task.
+# test via the 'rake' or 'rake test:path' task.
 #############################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
+require 'test-unit'
 require 'win32/file'
 
 class TC_Win32_File_Path < Test::Unit::TestCase
   def self.startup
-    Dir.chdir(File.dirname(File.expand_path(File.basename(__FILE__))))
+    Dir.chdir(File.expand_path(File.dirname(__FILE__)))
     @@file = File.join(Dir.pwd, 'path_test.txt')
     File.open(@@file, 'w'){ |fh| fh.puts "This is a path test." }
   end
 
   def setup
-    @long_file  = File.join(Dir.pwd, 'path_test.txt')      
-    @short_file = File.join(Dir.pwd, 'PATH_T~1.TXT')
+    @long_file  = File.join(Dir.pwd, 'path_test.txt').tr("/", "\\")
+    @short_file = File.join(Dir.pwd, 'PATH_T~1.TXT').tr("/", "\\")
   end
-   
+
   test "basename method basic functionality" do
     assert_respond_to(File, :basename)
     assert_nothing_raised{ File.basename("C:\\foo") }
     assert_kind_of(String, File.basename("C:\\foo"))
   end
-      
+
   test "basename method handles standard paths" do
     assert_equal("baz.txt", File.basename("C:\\foo\\bar\\baz.txt"))
     assert_equal("baz", File.basename("C:\\foo\\bar\\baz.txt", ".txt"))
@@ -37,14 +34,14 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal("foo", File.basename("C:\\foo"))
     assert_equal("C:\\", File.basename("C:\\"))
   end
-      
+
   test "basename method handles unc paths" do
     assert_equal("baz.txt", File.basename("\\\\foo\\bar\\baz.txt"))
     assert_equal("baz", File.basename("\\\\foo\\bar\\baz"))
     assert_equal("\\\\foo", File.basename("\\\\foo"))
     assert_equal("\\\\foo\\bar", File.basename("\\\\foo\\bar"))
   end
- 
+
   test "basename method handles forward slashes in standard unix paths" do
     assert_equal("bar", File.basename("/foo/bar"))
     assert_equal("bar.txt", File.basename("/foo/bar.txt"))
@@ -58,7 +55,7 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal("\\\\foo", File.basename("//foo"))
     assert_equal("\\\\foo\\bar", File.basename("//foo/bar"))
   end
-      
+
   test "basename method handles forward slashes in windows paths" do
     assert_equal("bar", File.basename("C:/foo/bar"))
     assert_equal("bar", File.basename("C:/foo/bar/"))
@@ -66,14 +63,14 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal("C:\\", File.basename("C:/"))
     assert_equal("bar", File.basename("C:/foo/bar//"))
   end
-         
+
   test "basename handles edge cases as expected" do
     assert_equal("", File.basename(""))
     assert_equal(".", File.basename("."))
     assert_equal("..", File.basename(".."))
     assert_equal("foo", File.basename("//foo/"))
   end
- 
+
   test "basename handles path names with suffixes" do
     assert_equal("bar", File.basename("bar.txt", ".txt"))
     assert_equal("bar", File.basename("/foo/bar.txt", ".txt"))
@@ -83,11 +80,11 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal("bar", File.basename("bar.txt", ".*"))
     assert_equal("bar.txt", File.basename("bar.txt.exe", ".*"))
   end
-      
+
   test "basename method does not modify its argument" do
     path = "C:\\foo\\bar"
     assert_nothing_raised{ File.basename(path) }
-    assert_equal("C:\\foo\\bar", path)    
+    assert_equal("C:\\foo\\bar", path)
   end
 
   test "basename removes all trailing slashes" do
@@ -99,13 +96,13 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal("foo.txt", File.basename("C:\\foo.txt\\\\\\"))
     assert_equal("foo.txt", File.basename("foo.txt\\\\\\"))
   end
-   
+
   test "dirname basic functionality" do
     assert_respond_to(File, :dirname)
     assert_nothing_raised{ File.dirname("C:\\foo") }
     assert_kind_of(String, File.dirname("C:\\foo"))
   end
-     
+
   test "dirname handles standard windows paths as expected" do
     assert_equal("C:\\foo", File.dirname("C:\\foo\\bar.txt"))
     assert_equal("C:\\foo", File.dirname("C:\\foo\\bar"))
@@ -113,14 +110,14 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal("C:\\", File.dirname("C:\\"))
     assert_equal(".", File.dirname("foo"))
   end
-      
+
   test "dirname handles unc windows paths as expected" do
     assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar\\baz"))
     assert_equal("\\\\foo\\bar", File.dirname("\\\\foo\\bar"))
     assert_equal("\\\\foo", File.dirname("\\\\foo"))
     assert_equal("\\\\", File.dirname("\\\\"))
   end
-    
+
   test "dirname handles forward slashes in standard windows path names" do
     assert_equal("C:\\foo", File.dirname("C:/foo/bar.txt"))
     assert_equal("C:\\foo", File.dirname("C:/foo/bar"))
@@ -139,14 +136,14 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal(".", File.dirname("./foo"))
     assert_equal(".\\foo", File.dirname("./foo/bar"))
   end
-    
+
   test "dirname handles various edge cases as expected" do
     assert_equal(".", File.dirname(""))
     assert_equal(".", File.dirname("."))
     assert_equal(".", File.dirname(".."))
     assert_equal(".", File.dirname("./"))
   end
-      
+
   test "dirname method does not modify its argument" do
     path = "C:\\foo\\bar"
     assert_nothing_raised{ File.dirname(path) }
@@ -171,9 +168,9 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_nothing_raised{ File.split("C:\\foo\\bar") }
     assert_kind_of(Array, File.split("C:\\foo\\bar"))
   end
-      
+
   test "split method handles standard windows path names" do
-    assert_equal(["C:\\foo", "bar"], File.split("C:\\foo\\bar"))     
+    assert_equal(["C:\\foo", "bar"], File.split("C:\\foo\\bar"))
     assert_equal([".", "foo"], File.split("foo"))
   end
 
@@ -181,13 +178,13 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal(["C:\\foo", "bar"], File.split("C:/foo/bar"))
     assert_equal([".", "foo"], File.split("foo"))
   end
-      
+
   test "split method handles standard unix paths as expected" do
     assert_equal(["\\foo","bar"], File.split("/foo/bar"))
     assert_equal(["\\", "foo"], File.split("/foo"))
     assert_equal([".", "foo"], File.split("foo"))
   end
-      
+
   test "split method handles unc paths as expected" do
     assert_equal(["\\\\foo\\bar", "baz"], File.split("\\\\foo\\bar\\baz"))
     assert_equal(["\\\\foo\\bar", ""], File.split("\\\\foo\\bar"))
@@ -199,22 +196,32 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal(["C:\\", ""], File.split("C:\\"))
     assert_equal(["", ""], File.split(""))
   end
-      
+
   test "split method does not modify its arguments" do
     path = "C:\\foo\\bar"
     assert_nothing_raised{ File.split(path) }
     assert_equal("C:\\foo\\bar", path)
   end
-   
-  test "long_path method works as expected" do
+
+  test "File.long_path basic functionality" do
     assert_respond_to(File, :long_path)
+    assert_nothing_raised{ File.long_path(@short_file) }
+    assert_kind_of(String, File.long_path(@short_file))
+  end
+
+  test "File.long_path returns the expected result" do
     assert_equal(@long_file, File.long_path(@short_file))
-    assert_equal('PATH_T~1.TXT', File.basename(@short_file))
   end
-   
-  test "short_path method works as expected" do
+
+  test "File.short_path basic functionality" do
     assert_respond_to(File, :short_path)
-    assert_equal('path_test.txt', File.basename(@long_file))
+    assert_nothing_raised{ File.short_path(@short_file) }
+    assert_kind_of(String, File.short_path(@short_file))
+  end
+
+  test "File.short_path returns the expected result" do
+    path = File.short_path(@long_file)
+    assert_equal('PATH_T~1.TXT', File.basename(path))
   end
 
   test "join method works as expected" do
@@ -243,7 +250,7 @@ class TC_Win32_File_Path < Test::Unit::TestCase
     assert_equal('foo', File.join('foo'))
     assert_equal('c:', File.join('c:'))
   end
-   
+
   def teardown
     @short_file = nil
     @long_file  = nil