win32-xpath 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b7fbc4af66e5ca073a64411ff6c48dcf4ab60ae
+  data.tar.gz: 2a1a3f3871c8bc63e70d133875e52760a98f6690
+SHA512:
+  metadata.gz: e1353c201cd8ef54a55600f3203aa06e6b20e55bc8682a07e3822bbe7f938ea7154d67a04b00260b7ffe77b480f568d9e159952dc23c4115821706b41508f591
+  data.tar.gz: 2b357454c4bad3722db57d7fbbf25ea2697cae1af585d332200d5950daeb633688a70582697f0ad23237472a09dbc55c52c04898fca9b4a8915edf6d41ccb283

data/CHANGES

@@ -0,0 +1,2 @@
+= 1.0.0 - 26-Feb-2015
+  * Initial release

data/MANIFEST

@@ -0,0 +1,9 @@
+bench/bench_win32_xpath.rb
+CHANGES
+ext/extconf.rb
+ext/win32/xpath.c
+futzing/futz.rb
+Rakefile
+README
+test/test_win32_xpath.rb
+win32-xpath.gemspec

data/README

@@ -0,0 +1,54 @@
+= Description
+  A custom File.expand_path method for Ruby on Windows that's much
+  faster and works better.
+
+= Installation
+  gem install win32-xpath
+
+= Synopsis
+  require 'win32/xpath'
+
+  # That's it, you are now using this library when you call File.expand_path
+
+= Features
+  * A 5x average performance boost over MRI's current method.
+  * Support for ~user expansion.
+
+= Known Issues
+  * This library does not support drive-current paths for the 2nd argument.
+  * This library does not support alt-stream name autocorrection.
+
+  It is very unlikely you will ever be affected by either of these things.
+  Drive-current paths are a relic of DOS 1.0, but even so this library
+  will handle them in the first argument.
+
+  I don't support alt-stream mangling because I don't believe it's the
+  job of this method to peform autocorrection. Even in MRI it only works
+  for the default $DATA stream, and then only for a certain type of
+  syntax error. I do not know when or why it was added.
+
+  If you discover any other issues, please report them on the project
+  page at https://github.com/djberg96/win32-xpath.
+
+= Acknowledgements
+  Park Heesob for encoding advice and help.
+
+== License
+  Artistic 2.0
+
+== Contributions
+  Although this library is free, please consider having your company
+  setup a gittip if used by your company professionally.
+
+  http://www.gittip.com/djberg96/
+    
+== Copyright
+  (C) 2003-2015 Daniel J. Berger, All Rights Reserved
+    
+== Warranty
+  This package 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 Berger

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rbconfig'
+include RbConfig
+
+CLEAN.include(
+  '**/*.gem',               # Gem files
+  '**/*.rbc',               # Rubinius
+  '**/*.o',                 # C object file
+  '**/*.log',               # Ruby extension build log
+  '**/Makefile',            # C Makefile
+  '**/*.def',               # Definition files
+  '**/*.exp',
+  '**/*.lib',
+  '**/*.pdb',
+  '**/*.obj',
+  '**/*.stackdump',         # Junk that can happen on Windows
+  "**/*.#{CONFIG['DLEXT']}" # C shared object
+)
+
+make = CONFIG['host_os'] =~ /mingw|cygwin/i ? 'make' : 'nmake'
+
+desc "Build the win32-xpath library"
+task :build => [:clean] do
+  require 'devkit' if CONFIG['host_os'] =~ /mingw|cygwin/i
+  Dir.chdir('ext') do
+    ruby "extconf.rb"
+    sh make
+    cp 'xpath.so', 'win32' # For testing
+  end
+end
+
+namespace :gem do
+  desc "Build the win32-xpath gem"
+  task :create => [:clean] do
+    require 'rubygems/package'
+    spec = eval(IO.read('win32-xpath.gemspec'))
+    Gem::Package.build(spec)
+  end
+
+  task "Install the win32-xpath gem"
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install -l #{file}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  task :test => [:build]
+  t.test_files = FileList['test/*']
+  t.libs << 'ext'
+end
+
+desc "Run benchmarks"
+task :bench => [:build] do
+  ruby "-Iext bench/bench_win32_xpath.rb"
+end
+
+task :default => :test

data/bench/bench_win32_xpath.rb

@@ -0,0 +1,79 @@
+require 'benchmark'
+
+MAX = 100000
+puts "\nOld File.expand_path"
+
+Benchmark.bm(30) do |x|
+  x.report("expand_path('foo/bar')") do
+    str = "foo/bar"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('C:/foo/bar')") do
+    str = "C:/foo/bar"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('//foo/bar')") do
+    str = "//foo/bar"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('foo//bar///')") do
+    str = "foo//bar///"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('~')") do
+    str = "~"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('')") do
+    str = ""
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('', '~')") do
+    MAX.times{ File.expand_path('', '~') }
+  end
+end
+
+require 'win32/xpath'
+puts "\nNew File.expand_path\n"
+
+Benchmark.bm(30) do |x|
+  x.report("expand_path('foo/bar')") do
+    str = "foo/bar"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('C:/foo/bar')") do
+    str = "C:/foo/bar"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('//foo/bar')") do
+    str = "//foo/bar"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('foo//bar///')") do
+    str = "foo//bar///"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('~')") do
+    str = "~"
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('')") do
+    str = ""
+    MAX.times{ File.expand_path(str) }
+  end
+
+  x.report("expand_path('', '~')") do
+    MAX.times{ File.expand_path('', '~') }
+  end
+end

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+have_library('shlwapi')
+have_library('advapi32')
+create_makefile('win32/xpath', 'win32')

data/ext/win32/xpath.c

@@ -0,0 +1,360 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <windows.h>
+#include <shlwapi.h>
+#include <sddl.h>
+
+#define MAX_WPATH MAX_PATH * sizeof(wchar_t)
+
+// Helper function to find user's home directory
+wchar_t* find_user(wchar_t* str){
+  SID* sid;
+  DWORD cbSid, cbDom, cbData, lpType;
+  SID_NAME_USE peUse;
+  LPWSTR str_sid;
+  LONG rv;
+  HKEY phkResult;
+  wchar_t subkey[MAX_PATH];
+  wchar_t* lpData;
+  wchar_t* dom;
+  wchar_t* ptr;
+  const wchar_t* key_base = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\";
+
+  // Read up until first backslash, and preserve the rest for later
+  if (ptr = wcschr(str, L'\\')){
+    ptr++;
+    str[wcscspn(str, L"\\")] = 0;
+  }
+
+  sid = (SID*)ruby_xmalloc(MAX_WPATH);
+  dom = (wchar_t*)ruby_xmalloc(MAX_WPATH);
+
+  cbSid = MAX_PATH;
+  cbDom = MAX_PATH;
+
+  // Get the user's SID
+  if (!LookupAccountNameW(NULL, str, sid, &cbSid, dom, &cbDom, &peUse)){
+    ruby_xfree(sid);
+    ruby_xfree(dom);
+    rb_raise(rb_eArgError, "can't find user %ls", str);
+  }
+
+  ruby_xfree(dom);
+    
+  // Get the stringy version of the SID
+  if (!ConvertSidToStringSidW(sid, &str_sid)){
+    ruby_xfree(sid);
+    rb_sys_fail("ConvertSidToStringSid");
+  }
+
+  ruby_xfree(sid);
+
+  // Mash the stringified SID onto our base key
+  if(swprintf(subkey, MAX_PATH, L"%s%s", key_base, str_sid) < 0)
+    rb_sys_fail("swprintf");
+
+  // Get the key handle we need
+  rv = RegOpenKeyExW(HKEY_LOCAL_MACHINE, subkey, 0, KEY_QUERY_VALUE, &phkResult);
+
+  if (rv != ERROR_SUCCESS)
+    rb_sys_fail("RegOpenKeyEx");
+
+  lpData = (wchar_t*)malloc(MAX_WPATH);
+  cbData = MAX_WPATH;
+  lpType = REG_EXPAND_SZ;
+
+  // Finally, get the user's home directory
+  rv = RegQueryValueExW(phkResult, L"ProfileImagePath", NULL, &lpType, (LPBYTE)lpData, &cbData);
+
+  if (rv != ERROR_SUCCESS){
+    ruby_xfree(lpData);
+    rb_raise(rb_eArgError, "can't find user %ls", str);
+  }
+
+  // Append any remaining path data that was originally present
+  if (ptr){
+    if (swprintf(lpData, MAX_WPATH, L"%s/%s", lpData, ptr) < 0)
+      rb_sys_fail("swprintf");
+  }
+  
+  return lpData;
+}
+
+// Helper function to expand tilde into full path
+wchar_t* expand_tilde(){
+  DWORD size = 0;
+  wchar_t* home = NULL;
+  const wchar_t* env = L"HOME";
+
+  // First, try to get HOME environment variable
+  size = GetEnvironmentVariableW(env, NULL, 0);
+
+  // If that isn't found then try USERPROFILE
+  if(!size){
+    env = L"USERPROFILE"; 
+    size = GetEnvironmentVariableW(env, home, size);
+  }
+
+  // If that isn't found the try HOMEDRIVE + HOMEPATH
+  if(!size){
+    DWORD size2;
+    wchar_t* temp;
+    wchar_t* env2 = L"HOMEPATH";
+    env = L"HOMEDRIVE";
+
+    // If neither are found then raise an error
+    size =  GetEnvironmentVariableW(env, NULL, 0);
+    size2 = GetEnvironmentVariableW(env2, NULL, 0);
+
+    if(!size || !size2){
+      if (GetLastError() != ERROR_ENVVAR_NOT_FOUND)
+        rb_sys_fail("GetEnvironmentVariable");
+      else
+        rb_raise(rb_eArgError, "couldn't find HOME environment -- expanding '~'");
+    }
+
+    home = (wchar_t*)ruby_xmalloc(MAX_WPATH);
+    temp = (wchar_t*)ruby_xmalloc(MAX_WPATH);
+
+    if(!GetEnvironmentVariableW(env, home, size) || !GetEnvironmentVariableW(env2, temp, size2)){
+      ruby_xfree(home);
+      ruby_xfree(temp);
+      rb_sys_fail("GetEnvironmentVariable");
+    }
+
+    if(!PathAppendW(home, temp))
+      rb_sys_fail("PathAppend");
+  }
+  else{
+    home = (wchar_t*)ruby_xmalloc(MAX_WPATH);
+    size = GetEnvironmentVariableW(env, home, size);
+
+    if(!size){
+      ruby_xfree(home);
+      rb_sys_fail("GetEnvironmentVariable");
+    }
+  }
+
+  while(wcsstr(home, L"/"))
+    home[wcscspn(home, L"/")] = L'\\';
+
+  if (PathIsRelativeW(home))
+    rb_raise(rb_eArgError, "non-absolute home");
+
+  return home;
+}
+
+// My version of File.expand_path
+static VALUE rb_xpath(int argc, VALUE* argv, VALUE self){
+  VALUE v_path, v_path_orig, v_dir_orig;
+  wchar_t* buffer = NULL;
+  wchar_t* ptr = NULL;
+  wchar_t* path = NULL;
+  char* final_path;
+  int length;
+  rb_encoding* path_encoding;
+  rb_econv_t* ec;
+  const int replaceflags = ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE;
+
+  rb_scan_args(argc, argv, "11", &v_path_orig, &v_dir_orig);
+
+  if (rb_respond_to(v_path_orig, rb_intern("to_path")))
+    v_path_orig = rb_funcall(v_path_orig, rb_intern("to_path"), 0, NULL);
+
+  SafeStringValue(v_path_orig);
+
+  if (!NIL_P(v_dir_orig))
+    SafeStringValue(v_dir_orig);
+
+  // Dup and prep string for modification
+  path_encoding = rb_enc_get(v_path_orig);
+
+  if (rb_enc_to_index(path_encoding) == rb_utf8_encindex()){
+    v_path = rb_str_dup(v_path_orig); 
+  }
+  else{
+    ec = rb_econv_open(rb_enc_name(path_encoding), "UTF-8", replaceflags);
+    v_path = rb_econv_str_convert(ec, v_path_orig, ECONV_PARTIAL_INPUT);
+    rb_econv_close(ec);
+  }
+  
+  rb_str_modify_expand(v_path, MAX_PATH);
+
+  // Make our path a wide string for later functions
+  length = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_path), -1, NULL, 0);
+  path = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
+
+  if(!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_path), -1, path, length)){
+    ruby_xfree(path);
+    rb_sys_fail("MultiByteToWideChar");
+  }
+
+  // Convert all forward slashes to backslashes to Windows API functions work properly
+  while(wcsstr(path, L"/"))
+    path[wcscspn(path, L"/")] = L'\\';
+
+  // Handle ~ expansion.
+  if (ptr = wcschr(path, L'~')){
+    wchar_t* home;
+
+    // Handle both ~/user and ~user syntax
+    if (ptr[1] && ptr[1] != L'\\'){
+      home = find_user(++ptr);
+    }
+    else{
+      home = expand_tilde(path);
+
+      if (!PathAppendW(home, ++ptr)){
+        ruby_xfree(home);
+        rb_sys_fail("PathAppend");
+      }
+    }
+
+    path = home;
+  }
+
+  // Directory argument is present
+  if (!NIL_P(v_dir_orig)){
+    wchar_t* dir;
+    VALUE v_dir;
+    rb_encoding* dir_encoding;
+
+    dir_encoding = rb_enc_get(v_dir_orig);
+
+    // Hooray for encodings
+    if (rb_enc_to_index(dir_encoding) == rb_utf8_encindex()){
+      v_dir = rb_str_dup(v_dir_orig);
+    }
+    else{
+      ec = rb_econv_open(rb_enc_name(dir_encoding), "UTF-8", replaceflags);
+      v_dir = rb_econv_str_convert(ec, v_dir_orig, ECONV_PARTIAL_INPUT);
+      rb_econv_close(ec);
+    }
+
+    // Prep string for modification
+    rb_str_modify_expand(v_dir, MAX_PATH);
+
+    length = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_dir), -1, NULL, 0);
+    dir = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
+
+    if (!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_dir), -1, dir, length)){
+      ruby_xfree(dir);
+      rb_sys_fail("MultiByteToWideChar");
+    }
+
+    while (wcsstr(dir, L"/"))
+      dir[wcscspn(dir, L"/")] = L'\\';
+
+    if (ptr = wcschr(dir, L'~')){
+      if (ptr[1] && ptr[1] != L'\\'){
+        dir = find_user(++ptr);
+      }
+      else{
+        dir = expand_tilde();
+
+        if (!PathAppendW(dir, ++ptr)){
+          ruby_xfree(dir);
+          rb_sys_fail("PathAppend");
+        }
+      }
+    }
+
+    if (!wcslen(path))
+      path = dir;
+
+    if (PathIsRelativeW(path)){ 
+      if(!PathAppendW(dir, path)){
+        ruby_xfree(dir);
+        rb_sys_fail("PathAppend");
+      }
+
+      // Remove leading slashes from relative paths
+      if (dir[0] == L'\\')
+        ++dir;
+
+      path = dir;
+    }
+  }
+  else{
+    if (!wcslen(path)){
+      char* pwd;
+      wchar_t* wpwd;
+
+      // First call, get the length
+      length = GetCurrentDirectoryW(0, NULL);
+      wpwd = (wchar_t*)ruby_xmalloc(length * sizeof(wchar_t));
+
+      length = GetCurrentDirectoryW(length, wpwd);
+
+      if(!length){
+        ruby_xfree(wpwd);
+        rb_sys_fail("GetCurrentDirectory");
+      }
+
+      // Convert backslashes into forward slashes
+      while(wcsstr(wpwd, L"\\"))
+        wpwd[wcscspn(wpwd, L"\\")] = L'/';
+
+      // Convert string back to multibyte string before returning Ruby object
+      length = WideCharToMultiByte(CP_UTF8, 0, wpwd, -1, NULL, 0, NULL, NULL);
+      pwd = (char*)ruby_xmalloc(length);
+      length = WideCharToMultiByte(CP_UTF8, 0, wpwd, -1, pwd, length, NULL, NULL);
+
+      if (!length){
+        ruby_xfree(pwd);
+        rb_sys_fail("WideCharToMultiByte");
+      }
+
+      return rb_str_new2(pwd);
+    }
+  }
+
+  // Strip all trailing backslashes
+  while (!*PathRemoveBackslashW(path));
+
+  // First call, get the length
+  length = GetFullPathNameW(path, 0, buffer, NULL);
+  buffer = (wchar_t*)ruby_xmalloc(length * sizeof(wchar_t));
+
+  // Now get the path
+  length = GetFullPathNameW(path, length, buffer, NULL);
+
+  if (!length){
+    ruby_xfree(buffer);
+    rb_sys_fail("GetFullPathName");
+  }
+
+  // Convert backslashes into forward slashes
+  while(wcsstr(buffer, L"\\"))
+    buffer[wcscspn(buffer, L"\\")] = L'/';
+
+  length = WideCharToMultiByte(CP_UTF8, 0, buffer, -1, NULL, 0, NULL, NULL);
+  final_path = (char*)ruby_xmalloc(length);
+  length = WideCharToMultiByte(CP_UTF8, 0, buffer, -1, final_path, length, NULL, NULL);
+
+  ruby_xfree(buffer);
+
+  if (!length){
+    ruby_xfree(final_path);
+    rb_sys_fail("WideCharToMultiByte");
+  }
+
+  v_path = rb_str_new(final_path, length - 1); // Don't count null terminator
+
+  if (rb_enc_to_index(path_encoding) != rb_utf8_encindex()){
+    ec = rb_econv_open("UTF-8", rb_enc_name(path_encoding), replaceflags);
+    v_path = rb_econv_str_convert(ec, v_path, ECONV_PARTIAL_INPUT);
+    rb_econv_close(ec);    
+  }
+
+  rb_enc_associate(v_path, path_encoding);
+  
+  if (OBJ_TAINTED(v_path_orig) || rb_equal(v_path, v_path_orig) == Qfalse)
+    OBJ_TAINT(v_path);
+
+  return v_path;
+}
+
+void Init_xpath(){
+  rb_define_singleton_method(rb_cFile, "expand_path", rb_xpath, -1);
+}

data/futzing/futz.rb

@@ -0,0 +1,71 @@
+require 'win32/xpath'
+require 'tmpdir'
+
+#p File.expand_path("~djberge", "foo")
+#p File.expand_path("~/foo")
+#p File.expand_path("", "~djberge")
+#p File.expand_path("~djberge")
+#p File.expand_path("~djberge/foo/bar")
+#p File.expand_path("~bogus")
+
+ENV['HOME'] = nil
+ENV['USERPROFILE'] = nil
+ENV['HOMEDRIVE'] = "D:/"
+#ENV['USERPROFILE'] = "C:/bogus"
+p File.expand_path("~")
+
+#p File.expand_path("foo", "~")
+#p File.expand_path("foo", "~")
+#p File.expand_path("", "~")
+#p File.expand_path("", "~")
+#p File.expand_path("foo", "~/bar")
+#p File.expand_path("foo", "~/bar")
+#p File.expand_path("")
+#p File.expand_path("C:/foo/bar")
+#p File.expand_path("C:/foo/bar///")
+#p File.expand_path('foo', Dir.tmpdir)
+#p File.expand_path("C:/foo/bar", "D:/foo")
+#p File.expand_path("foo")
+#p File.expand_path("foo", "bar")
+
+#ENV['HOME'] = nil
+#ENV['USERPROFILE'] = nil
+#p File.expand_path("~")
+
+#path = "../a"
+#tmp = Dir.tmpdir
+
+#p path
+#p tmp
+
+#100.times{
+#  File.expand_path(path, tmp)
+#  File.expand_path('foo', tmp)
+#}
+
+#p path
+#p tmp
+
+#p File.expand_path('../a', tmp)
+
+#p File.expand_path('../a', 'foo')
+#p File.expand_path('../a', 'foo')
+#p File.expand_path('../a', 'C:/foo')
+#p File.expand_path('../a', 'C:/foo')
+
+
+=begin
+p File.expand_path("/foo").tainted?
+p File.expand_path("foo").tainted? # True
+p File.expand_path("foo".taint).tainted? # True
+p File.expand_path("C:/foo").tainted? # False
+p File.expand_path("C:/foo".taint).tainted? # True
+=end
+
+=begin
+p File.expand_path("~")
+p File.expand_path("~/foo")
+p File.expand_path("//foo/bar")
+p File.expand_path("//foo/bar//")
+p File.expand_path("//foo/bar//")
+=end

data/futzing/test.rb

@@ -0,0 +1,90 @@
+require 'ffi'
+
+class Windows
+  extend FFI::Library
+  typedef :ulong, :dword
+
+  ffi_lib :shlwapi
+
+  attach_function :PathCanonicalizeA, [:buffer_out, :string], :bool
+  attach_function :PathStripToRootA, [:pointer], :bool
+  attach_function :PathIsRelativeA, [:string], :bool
+  attach_function :PathAppendA, [:buffer_out, :string], :bool
+  attach_function :PathSkipRootA, [:string], :string
+  attach_function :PathIsNetworkPathA, [:string], :bool
+
+  ffi_lib :kernel32
+  attach_function :GetFullPathNameA, [:string, :dword, :buffer_out, :pointer], :dword
+
+  def xpath(path, dir=nil)
+    path = path.tr("/", "\\")
+
+    buf = 0.chr * 512
+
+    p path
+    p PathIsRelativeA(path)
+
+    if !PathCanonicalizeA(buf, path)
+      raise
+    end
+
+    p buf.strip
+
+    #p dir
+    #p path
+
+    #regex = /\A(\w):([^\\]+)(.*)/i
+=begin
+    if m = regex.match(path)
+      drive = m.captures[0]
+      path = m.captures[1..-1].join
+      p drive
+      p path
+    end
+=end
+
+    #p PathIsNetworkPathA(path)
+    #p PathSkipRootA(path)
+    #p PathIsRelativeA(path)
+
+=begin
+    buf = 0.chr * 1024
+
+    if GetFullPathNameA(path, buf.size, buf, nil) == 0
+      raise SystemCallError.new('GetFullPathName', FFI.errno)
+    end
+
+    p buf.strip
+=end
+
+=begin
+    ptr = FFI::MemoryPointer.from_string(path)
+
+    p PathIsRelativeA(path)
+
+    unless PathStripToRootA(ptr)
+      raise SystemCallError.new('PathStripToRoot', FFI.errno)
+    end
+
+    p ptr.read_string
+=end
+
+=begin
+    unless PathCanonicalizeA(buf, path)
+      raise SystemCallError.new('PathCanonicalize', FFI.errno)
+    end
+
+    buf.strip
+=end
+  end
+end
+
+if $0 == __FILE__
+  Windows.new.xpath("/../../a", "foo")
+  #p Windows.new.xpath("C:/foo/../bar")
+  #p Windows.new.xpath("C:foo")
+  #Windows.new.xpath("C:foo")
+  #Windows.new.xpath("C:foo/bar")
+  #Windows.new.xpath("C:/foo")
+  #Windows.new.xpath("foo")
+end

data/test/test_win32_xpath.rb

@@ -0,0 +1,185 @@
+require 'test-unit'
+require 'tmpdir'
+require 'win32/xpath'
+require 'etc'
+
+class Test_XPath < Test::Unit::TestCase
+  def self.startup
+    ENV['HOME'] ||= ENV['USERPROFILE']
+    @@login = Etc.getlogin
+  end
+
+  def setup
+    @pwd = Dir.pwd
+    @tmp = Dir.tmpdir
+    @root =  'C:/'
+    @drive = ENV['HOMEDRIVE']
+    @home = ENV['HOME'].tr('\\', '/')
+    @unc = "//foo/bar"
+  end
+
+  test "converts an empty pathname into absolute current pathname" do
+    assert_equal(@pwd, File.expand_path(''))
+  end
+
+  test "converts '.' into absolute pathname using current directory" do
+    assert_equal(@pwd, File.expand_path('.'))
+  end
+
+  test "converts 'foo' into absolute pathname using current directory" do
+    assert_equal(File.join(@pwd, 'foo'), File.expand_path('foo'))
+  end
+
+  test "converts 'foo' into absolute pathname ignoring nil dir" do
+    assert_equal(File.join(@pwd, 'foo'), File.expand_path('foo', nil))
+  end
+
+  test "converts 'foo' and 'bar' into absolute pathname" do
+    assert_equal(File.join(@pwd, "bar", "foo"), File.expand_path('foo', 'bar'))
+  end
+
+  test "converts a pathname into absolute pathname" do
+    assert_equal(File.join(@pwd, 'a'), File.expand_path('a.'))
+    assert_equal(File.join(@pwd, '.a'), File.expand_path('.a'))
+    assert_equal(File.join(@pwd, '..a'), File.expand_path('..a'))
+    assert_equal(File.join(@pwd, 'a../b'), File.expand_path('a../b'))
+  end
+
+  test "converts a pathname and make it valid" do
+    assert_equal(File.join(@pwd, 'a'), File.expand_path('a..'))
+  end
+
+  test "converts a pathname to an absolute pathname using a complete path" do
+    assert_equal(@tmp, File.expand_path('', @tmp))
+    assert_equal(File.join(@tmp, 'a'), File.expand_path('a', @tmp))
+    assert_equal(File.join(@tmp, 'a'), File.expand_path('../a', "#{@tmp}/xxx"))
+    assert_equal(@root, File.expand_path('.', @root))
+  end
+
+  test "ignores supplied dir if path contains a drive letter" do
+    assert_equal(@root, File.expand_path(@root, "D:/"))
+  end
+
+  test "removes trailing slashes from absolute path" do
+    assert_equal(File.join(@root, 'foo'), File.expand_path("#{@root}foo/"))
+    assert_equal(File.join(@root, 'foo.rb'), File.expand_path("#{@root}foo.rb/"))
+  end
+
+  test "removes trailing spaces from absolute path" do
+    assert_equal(File.join(@root, 'foo'), File.expand_path("#{@root}foo  "))
+  end
+
+  test "removes trailing dots from absolute path" do
+    assert_equal(File.join(@root, 'a'), File.expand_path("#{@root}a."))
+  end
+
+  test "converts a pathname with a drive letter but no slash" do
+    assert_match(/\Ac:\//i, File.expand_path("c:"))
+  end
+
+  test "converts a pathname with a drive letter ignoring different drive dir" do
+    assert_match(/\Ac:\//i, File.expand_path("c:foo", "d:/bar"))
+  end
+
+  test "converts a pathname which starts with a slash using current drive" do
+    assert_match(/\A#{@drive}\/foo\z/i, File.expand_path('/foo'))
+  end
+
+  test "returns tainted strings or not" do
+    assert_true(File.expand_path('foo').tainted?)
+    assert_true(File.expand_path('foo'.taint).tainted?)
+    assert_true(File.expand_path('/foo').tainted?)
+    assert_true(File.expand_path('/foo'.taint).tainted?)
+    assert_true(File.expand_path('C:/foo'.taint).tainted?)
+    assert_false(File.expand_path('C:/foo').tainted?)
+    assert_false(File.expand_path('//foo').tainted?)
+  end
+
+  test "converts a pathname to an absolute pathname using tilde as base" do
+    assert_equal(@home, File.expand_path('~'))
+    assert_equal("#{@home}/foo", File.expand_path('~/foo'))
+  end
+
+  test "converts a pathname to an absolute pathname using tilde for UNC path" do
+    ENV['HOME'] = @unc
+    assert_equal(@unc, File.expand_path('~'))
+  end
+
+  test "converts a tilde to path if used for dir argument" do
+    assert_equal(@home, File.expand_path('', '~'))
+    assert_equal("#{@home}/foo", File.expand_path('', '~/foo'))
+    assert_equal("#{@home}/foo", File.expand_path('foo', '~'))
+  end
+
+  test "does not modify a HOME string argument" do
+    str = "~/a"
+    assert_equal("#{@home}/a", File.expand_path(str))
+    assert_equal("~/a", str)
+  end
+
+  test "raises ArgumentError when HOME is nil" do
+    ENV['HOME'] = nil
+    ENV['USERPROFILE'] = nil
+    ENV['HOMEDRIVE'] = nil
+    assert_raise(ArgumentError){ File.expand_path('~') }
+  end
+
+  test "raises ArgumentError if HOME is relative" do
+    ENV['HOME'] = '.'
+    assert_raise(ArgumentError){ File.expand_path('~') }
+  end
+
+  test "raises ArgumentError if relative user is provided" do
+    ENV['HOME'] = '.'
+    assert_raise(ArgumentError){ File.expand_path('~anything') }
+  end
+
+  test "raises an ArgumentError if a bogus username is supplied" do
+    assert_raise(ArgumentError){ File.expand_path('~anything') }
+  end
+
+  test "converts a tilde plus username as expected" do
+    assert_equal("C:/Users/#{@@login}", File.expand_path("~#{@@login}"))
+    assert_equal("C:/Users/#{@@login}/foo", File.expand_path("~#{@@login}/foo"))
+  end
+
+  test "raises a TypeError if not passed a string" do
+    assert_raise(TypeError){ File.expand_path(1) }
+    assert_raise(TypeError){ File.expand_path(nil) }
+    assert_raise(TypeError){ File.expand_path(true) }
+  end
+
+  test "canonicalizes absolute path" do
+    assert_equal("C:/dir", File.expand_path("C:/./dir"))
+  end
+
+  test "does not modify its argument" do
+    str = "./a/b/../c"
+    assert_equal("#{@home}/a/c", File.expand_path(str, @home))
+    assert_equal("./a/b/../c", str)
+  end
+
+  test "accepts objects that have a to_path method" do
+    klass = Class.new{ def to_path; "a/b/c"; end }
+    obj = klass.new
+    assert_equal("#{@pwd}/a/b/c", File.expand_path(obj))
+  end
+
+  test "works with unicode characters" do
+    assert_equal("#{@pwd}/Ελλάσ", File.expand_path("Ελλάσ"))
+  end
+
+  def teardown
+    @pwd = nil
+    @unc = nil
+    @dir = nil
+    @root = nil
+    @drive = nil
+
+    ENV['HOME'] = @home
+  end
+
+  def self.shutdown
+    @@login = nil
+  end
+end

data/win32-xpath.gemspec

@@ -0,0 +1,25 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name      = 'win32-xpath'
+  spec.version   = '1.0.0'
+  spec.author    = 'Daniel J. Berger'
+  spec.license   = 'Artistic 2.0'
+  spec.email     = 'djberg96@gmail.com'
+  spec.homepage  = 'http://github.com/djberg96/win32-xpath'
+  spec.summary   = 'Revamped File.expand_path for Windows'
+  spec.test_file = 'test/test_win32_xpath.rb'
+  spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+
+  spec.extensions = ['ext/extconf.rb']
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('test-unit', '>= 3.0.0')
+
+  spec.description = <<-EOF
+    The win32-xpath library provides a revamped File.expand_path method
+    for MS Windows. It is significantly faster, and supports ~user
+    expansion as well.
+  EOF
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: win32-xpath
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: |2
+      The win32-xpath library provides a revamped File.expand_path method
+      for MS Windows. It is significantly faster, and supports ~user
+      expansion as well.
+email: djberg96@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- README
+- CHANGES
+- MANIFEST
+files:
+- CHANGES
+- MANIFEST
+- README
+- Rakefile
+- bench/bench_win32_xpath.rb
+- ext/extconf.rb
+- ext/win32/xpath.c
+- futzing/futz.rb
+- futzing/test.rb
+- test/test_win32_xpath.rb
+- win32-xpath.gemspec
+homepage: http://github.com/djberg96/win32-xpath
+licenses:
+- Artistic 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Revamped File.expand_path for Windows
+test_files:
+- test/test_win32_xpath.rb