win32-api 1.0.6-x86-mswin32-60 → 1.1.0-x86-mswin32-60

data/CHANGES

@@ -1,3 +1,8 @@
+= 1.1.0 - 12-Jun-2008
+* Added the Windows::API::Function class. This is a subclass of Win32::API
+  meant only for use with raw function pointers.
+* Some documentation updates in the source and README files.
+
 = 1.0.6 - 18-Apr-2008
 * Added the effective_function_name method. This allows you to see what the
   actual function name is that was defined, e.g. GetUserNameA vs GetUserNameW.

data/MANIFEST

@@ -5,5 +5,6 @@
 * win32-api.gemspec
 * ext/extconf.rb
 * ext/win32/api.c
-* test/tc_win32_api_callback.rb
-* test/tc_win32_api.rb
+* test/test_win32_api.rb
+* test/test_win32_api_callback.rb
+* test/test_win32_api_function.rb

data/README

@@ -1,85 +1,98 @@
-= Description
-   This is a drop-in replacement for the Win32API library currently part of
-   Ruby's standard library.
-	
-= Synopsis
-   require 'win32/api'
-   include Win32
-   
-   buf = 0.chr * 260
-   len = [@buf.length].pack('L')
-   
-   GetUserName = API.new('GetUserName', 'PP', 'I', 'advapi32')
-   GetUserName.call(buf, len)
-   
-   puts buf.strip
-   
-   # Callback example
-   EnumWindows     = API.new('EnumWindows', 'KP', 'L', 'user32')
-   GetWindowText   = API.new('GetWindowText', 'LPI', 'I', 'user32')
-   EnumWindowsProc = API::Callback.new('LP', 'I'){ |handle, param|
-      buf = "\0" * 200
-      GetWindowText.call(handle, buf, 200);
-      puts buf.strip
-      buf.index(param).nil? ? true : false
-   } 
-   
-= Differences between win32-api and Win32API
-   * This library has callback support!
-   * Argument order change. The DLL name is now last, not first.
-   * Removed the 'N' and 'n'. Always use 'L' for longs now.
-   * Sensible default arguments for the prototype, return type and DLL name.
-   * Reader methods for the function name, prototype, return type and DLL.
-   * Removed the support for lower case prototype and return types. Always
-     use capital letters.
-   * Resorts to wide character functions (where possible) when $KCODE is set
-     to UTF8.
-   
-= Developer's Notes
-   The current Win32API library that ships with the standard library has been
-   slated for removal from Ruby 2.0 and it will not receive any updates in the
-   Ruby 1.8.x branch. I have far too many libraries invested in it to let it
-   die at this point.
-   
-   In addition, the current Win32API library was written in the bad old Ruby
-   1.6.x days, which means it doesn't use the newer allocation framework.
-   There were several other refactorings that I felt it needed to more closely
-   match how it was actually being used in practice.
-   
-   The first order of business was changing the order of the arguments. By
-   moving the DLL name from first to last, I was able to provide reasonable
-   default arguments for the prototype, return type and the DLL. Only the
-   function name is required now.
-   
-   There was a laundry list of other refactorings that were needed: sensical
-   instance variable names with proper accessors, removing support for lower
-   case prototype and return value characters that no one used in practice,
-   better naming conventions, the addition of RDoc ready comments and,
-   especially, callback support.
-   
-   Most importantly, we can now add, modify and fix any features that we feel
-   best benefit our end users.
-
-= Documentation
-   The source file contains inline RDoc documentation. If you installed
-   this file as a gem, then you have the docs.
-   
-= 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.
-   
-= Known Bugs
-   None that I'm aware of. Please submit any bug reports to the project page
-   at http://www.rubyforge.org/projects/win32utils.
-
-= Copyright
-   (C) 2003-2007 Daniel J. Berger
-   All Rights Reserved
-
-= License
-   Ruby's
-
-= Authors
-   Daniel J. Berger
+= Description
+   This is a drop-in replacement for the Win32API library currently part of
+   Ruby's standard library.
+	
+= Synopsis
+   require 'win32/api'
+   include Win32
+   
+   # Typical example - Get user name
+   buf = 0.chr * 260
+   len = [buf.length].pack('L')
+   
+   GetUserName = API.new('GetUserName', 'PP', 'I', 'advapi32')
+   GetUserName.call(buf, len)
+   
+   puts buf.strip
+   
+   # Callback example - Enumerate windows
+   EnumWindows     = API.new('EnumWindows', 'KP', 'L', 'user32')
+   GetWindowText   = API.new('GetWindowText', 'LPI', 'I', 'user32')
+   EnumWindowsProc = API::Callback.new('LP', 'I'){ |handle, param|
+      buf = "\0" * 200
+      GetWindowText.call(handle, buf, 200);
+      puts buf.strip unless buf.strip.empty?
+      buf.index(param).nil? ? true : false
+   }
+   
+   EnumWindows.call(EnumWindowsProc, 'UEDIT32')
+   
+   # Raw function pointer example - System beep
+   LoadLibrary    = API.new('LoadLibrary', 'P', 'L')
+   GetProcAddress = API.new('GetProcAddress', 'LP', 'L')
+ 
+   hlib = LoadLibrary.call('user32')
+   addr = GetProcAddress.call(hlib, 'MessageBeep')
+   func = Win32::API::Function.new(addr, 'L', 'L')
+   func.call(0)
+   
+= Differences between win32-api and Win32API
+   * This library has callback support
+   * This library supports raw function pointers.
+   * Argument order change. The DLL name is now last, not first.
+   * Removed the 'N' and 'n'. Always use 'L' for longs now.
+   * Sensible default arguments for the prototype, return type and DLL name.
+   * Reader methods for the function name, prototype, return type and DLL.
+   * Removed the support for lower case prototype and return types. Always
+     use capital letters.
+   * Resorts to wide character functions (where possible) when $KCODE is set
+     to UTF8.
+   
+= Developer's Notes
+   The current Win32API library that ships with the standard library has been
+   slated for removal from Ruby 2.0 and it will not receive any updates in the
+   Ruby 1.8.x branch. I have far too many libraries invested in it to let it
+   die at this point.
+   
+   In addition, the current Win32API library was written in the bad old Ruby
+   1.6.x days, which means it doesn't use the newer allocation framework.
+   There were several other refactorings that I felt it needed to more closely
+   match how it was actually being used in practice.
+   
+   The first order of business was changing the order of the arguments. By
+   moving the DLL name from first to last, I was able to provide reasonable
+   default arguments for the prototype, return type and the DLL. Only the
+   function name is required now.
+   
+   There was a laundry list of other refactorings that were needed: sensical
+   instance variable names with proper accessors, removing support for lower
+   case prototype and return value characters that no one used in practice,
+   better naming conventions, the addition of RDoc ready comments and,
+   especially, callback support.
+   
+   Most importantly, we can now add, modify and fix any features that we feel
+   best benefit our end users.
+
+= Documentation
+   The source file contains inline RDoc documentation. If you installed
+   this file as a gem, then you have the docs.
+   
+= 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.
+   
+= Known Bugs
+   None that I'm aware of. Please submit any bug reports to the project page
+   at http://www.rubyforge.org/projects/win32utils.
+
+= Copyright
+   (C) 2003-2008 Daniel J. Berger
+   All Rights Reserved
+
+= License
+   Ruby's
+
+= Authors
+   Daniel J. Berger
    Park Heesob

data/ext/extconf.rb

@@ -0,0 +1,11 @@
+##########################################################################
+# extconf.rb
+# 
+# The Windows::API binary should be built using the Rake task, i.e.
+# 'rake build' or 'rake install'.
+##########################################################################
+require 'mkmf'
+
+have_func('strncpy_s')
+
+create_makefile('win32/api', 'win32')

data/ext/win32/api.c

@@ -2,7 +2,7 @@
 #include <windows.h>
 
 #define MAX_BUF 1024
-#define WINDOWS_API_VERSION "1.0.6"
+#define WINDOWS_API_VERSION "1.1.0"
 
 #define _T_VOID     0
 #define _T_LONG     1
@@ -12,8 +12,28 @@
 
 VALUE cAPIError, cCallbackError;
 
+typedef struct {
+    HANDLE library;
+    FARPROC function;
+    int return_type;
+    int prototype[16];
+} Win32API;
+
+static void api_free(Win32API* ptr){
+   if(ptr->library)
+      FreeLibrary(ptr->library);
+
+   if(ptr)
+      free(ptr);
+}
+
+static VALUE api_allocate(VALUE klass){
+   Win32API* ptr = malloc(sizeof(Win32API));
+   return Data_Wrap_Struct(klass, 0, api_free, ptr);
+}
+
 /* Helper function that converts the error number returned by GetLastError()
- * into a human readable string.  Internal use only.
+ * into a human readable string. Internal use only.
  */
 char* StringError(DWORD dwError){
    LPVOID lpMsgBuf;
@@ -52,10 +72,11 @@ char* StringError(DWORD dwError){
 
 /*
  * call-seq:
- *    Win32::API::Callback.new(prototype, return='L')
+ *    Win32::API::Callback.new(prototype, return='L'){ |proto| ... }
  * 
- * Creates and returns a new Win32::API::Callback object. The +function+ is
- * the name of the Windows function.
+ * Creates and returns a new Win32::API::Callback object. The prototype
+ * arguments are yielded back to the block in the same order they were
+ * declared.
  * 
  * The +prototype+ is the function prototype for the callback function. This
  * is a string. The possible valid characters are 'I' (integer), 'L' (long),
@@ -65,6 +86,21 @@ char* StringError(DWORD dwError){
  * The +return+ argument is the return type for the callback function. The
  * valid characters are the same as for the +prototype+. The default is
  * 'L' (long).
+ * 
+ * Example:
+ *    require 'win32/api'
+ *    include Win32
+ * 
+ *    EnumWindows = API.new('EnumWindows', 'KP', 'L', 'user32')
+ *    GetWindowText = API.new('GetWindowText', 'LPI', 'I', 'user32')
+ *    EnumWindowsProc = API::Callback.new('LP', 'I'){ |handle, param|
+ *       buf = "\0" * 200
+ *       GetWindowText.call(handle, buf, 200);
+ *       puts buf.strip unless buf.strip.empty?
+ *       buf.index(param).nil? ? true : false
+ *    }
+ *  
+ *    EnumWindows.call(EnumWindowsProc, 'UEDIT32')
  */
 static VALUE callback_init(int argc, VALUE* argv, VALUE self)
 {
@@ -91,27 +127,7 @@ static VALUE callback_init(int argc, VALUE* argv, VALUE self)
    rb_iv_set(self, "@prototype", v_proto);
    rb_iv_set(self, "@return_type", v_return);
     
-    return self;
-}
-
-
-typedef struct {
-    HANDLE library;
-    FARPROC function;
-    int return_type;
-    int prototype[16];
-} Win32API;
-
-static void api_free(Win32API* ptr){
-   if(ptr->library)
-      FreeLibrary(ptr->library);
-
-   free(ptr);
-}
-
-static VALUE api_allocate(VALUE klass){
-   Win32API* ptr = malloc(sizeof(Win32API));
-   return Data_Wrap_Struct(klass, 0, api_free, ptr);
+   return self;
 }
 
 /*
@@ -134,6 +150,19 @@ static VALUE api_allocate(VALUE klass){
  * 
  * If the function cannot be found then an API::Error is raised (a subclass
  * of RuntimeError).
+ * 
+ * Example:
+ * 
+ *    require 'win32/api'
+ *    include Win32
+ * 
+ *    buf = 0.chr * 260
+ *    len = [buf.length].pack('L')
+ *  
+ *    GetUserName = API.new('GetUserName', 'PP', 'I', 'advapi32')
+ *    GetUserName.call(buf, len)
+ * 
+ *    puts buf.strip
  */
 static VALUE api_init(int argc, VALUE* argv, VALUE self)
 {
@@ -149,25 +178,25 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
    
    Data_Get_Struct(self, Win32API, ptr);
 
-   /* Convert a string prototype to an array of characters */
+   // Convert a string prototype to an array of characters
    if(rb_respond_to(v_proto, rb_intern("split")))
       v_proto = rb_str_split(v_proto, "");
 
-   /* Set an arbitrary limit of 16 parameters */
-   if(16 < RARRAY(v_proto)->len)
-      rb_raise(rb_eArgError, "too many parameters: %d\n", RARRAY(v_proto)->len);
-
-   /* Convert a nil or empty prototype to 'V' (void) automatically */
+   // Convert a nil or empty prototype to 'V' (void) automatically
    if(NIL_P(v_proto) || RARRAY(v_proto)->len == 0){
       v_proto = rb_ary_new();
       rb_ary_push(v_proto, rb_str_new2("V"));
    }
+
+   // Set an arbitrary limit of 16 parameters
+   if(16 < RARRAY(v_proto)->len)
+      rb_raise(rb_eArgError, "too many parameters: %d\n", RARRAY(v_proto)->len);
    
-   /* Set the default dll to 'kernel32' */
+   // Set the default dll to 'kernel32'
    if(NIL_P(v_dll))
    	v_dll = rb_str_new2("kernel32");
    	
-   /* Set the default return type to 'L' (DWORD) */
+   // Set the default return type to 'L' (DWORD)
    if(NIL_P(v_return))
    	v_return = rb_str_new2("L");
 
@@ -176,7 +205,7 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
 
    hLibrary = LoadLibrary(TEXT(RSTRING(v_dll)->ptr));
 
-   /* The most likely cause of failure is a bad DLL load path */
+   // The most likely cause of failure is a bad DLL load path
    if(!hLibrary){
       rb_raise(cAPIError, "LoadLibrary() function failed for '%s': %s",
          RSTRING(v_dll)->ptr,
@@ -192,7 +221,7 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
     */
    fProc = GetProcAddress(hLibrary, TEXT(RSTRING(v_proc)->ptr));
 
-   /* The order of 'A' and 'W' is reversed if $KCODE is set to 'UTF8'. */
+   // The order of 'A' and 'W' is reversed if $KCODE is set to 'UTF8'.
    if(!strcmp(rb_get_kcode(), "UTF8")){
       first  = "W";
       second = "A";
@@ -232,7 +261,8 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
 
    ptr->function = fProc;
 
-   /* Push the numeric prototypes onto our int array for later use. */
+   // Push the numeric prototypes onto our int array for later use.
+
    for(i = 0; i < RARRAY(v_proto)->len; i++){
       SafeStringValue(RARRAY(v_proto)->ptr[i]);
       switch(*(char*)StringValuePtr(RARRAY(v_proto)->ptr[i])){
@@ -256,9 +286,9 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
       }
    }
 
-   /* Store the return type for later use.  Automatically convert empty
-    * strings or nil to type void.
-    */
+   // Store the return type for later use.
+
+   // Automatically convert empty strings or nil to type void.
    if(NIL_P(v_return) || RSTRING(v_return)->len == 0){
       v_return = rb_str_new2("V");
       ptr->return_type = _T_VOID;
@@ -291,6 +321,121 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
    return self;
 }
 
+/*
+ * call-seq:
+ *
+ *    API::Function.new(address, prototype = 'V', return_type = 'L')
+ *
+ * Creates and returns an API::Function object. This object is similar to an
+ * API object, except that instead of a character function name you pass a
+ * function pointer address as the first argument, and there's no associated
+ * DLL file.
+ *
+ * Once you have your API::Function object you can then call it the same way
+ * you would an API object.
+ *
+ * Example:
+ *
+ *    require 'win32/api'
+ *    include Win32
+ *
+ *    LoadLibrary = API.new('LoadLibrary', 'P', 'L')
+ *    GetProcAddress = API.new('GetProcAddress', 'LP', 'L')
+ *
+ *    # Play a system beep
+ *    hlib = LoadLibrary.call('user32')
+ *    addr = GetProcAddress.call(hlib, 'MessageBeep')
+ *    func = Win32::API::Function.new(addr, 'L', 'L')
+ *    func.call(0)
+ */
+static VALUE func_init(int argc, VALUE* argv, VALUE self){
+   Win32API* ptr;
+   int i;
+   VALUE v_address, v_proto, v_return;
+
+   rb_scan_args(argc, argv, "12", &v_address, &v_proto, &v_return);
+
+   Data_Get_Struct(self, Win32API, ptr);
+
+   // Convert a string prototype to an array of characters
+   if(rb_respond_to(v_proto, rb_intern("split")))
+      v_proto = rb_str_split(v_proto, "");
+
+   // Convert a nil or empty prototype to 'V' (void) automatically
+   if(NIL_P(v_proto) || RARRAY(v_proto)->len == 0){
+      v_proto = rb_ary_new();
+      rb_ary_push(v_proto, rb_str_new2("V"));
+   }
+
+   // Set an arbitrary limit of 16 parameters
+   if(16 < RARRAY(v_proto)->len)
+      rb_raise(rb_eArgError, "too many parameters: %d\n", RARRAY(v_proto)->len);
+
+   // Set the default return type to 'L' (DWORD)
+   if(NIL_P(v_return))
+   	v_return = rb_str_new2("L");
+
+   ptr->function = (FARPROC)NUM2LONG(v_address);
+
+   // Push the numeric prototypes onto our int array for later use.
+
+   for(i = 0; i < RARRAY(v_proto)->len; i++){
+      SafeStringValue(RARRAY(v_proto)->ptr[i]);
+      switch(*(char*)StringValuePtr(RARRAY(v_proto)->ptr[i])){
+         case 'L':
+            ptr->prototype[i] = _T_LONG;
+            break;
+         case 'P':
+            ptr->prototype[i] = _T_POINTER;
+            break;
+         case 'I': case 'B':
+            ptr->prototype[i] = _T_INTEGER;
+            break;
+         case 'V':
+            ptr->prototype[i] = _T_VOID;
+            break;
+         case 'K':
+            ptr->prototype[i] = _T_CALLBACK;
+            break;
+         default:
+            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
+      }
+   }
+
+   // Store the return type for later use.
+
+   // Automatically convert empty strings or nil to type void.
+   if(NIL_P(v_return) || RSTRING(v_return)->len == 0){
+      v_return = rb_str_new2("V");
+      ptr->return_type = _T_VOID;
+   }
+   else{
+      SafeStringValue(v_return);
+      switch(*RSTRING(v_return)->ptr){
+         case 'L':
+            ptr->return_type = _T_LONG;
+            break;
+         case 'P':
+            ptr->return_type = _T_POINTER;
+            break;
+         case 'I': case 'B':
+            ptr->return_type = _T_INTEGER;
+            break;
+         case 'V':
+            ptr->return_type = _T_VOID;
+            break;
+         default:
+            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
+      }
+   }
+
+   rb_iv_set(self, "@address", v_address);
+   rb_iv_set(self, "@prototype", v_proto);
+   rb_iv_set(self, "@return_type", v_return);
+
+   return self;
+}
+
 typedef struct {
    DWORD params[1];
 } PARAM;
@@ -481,7 +626,7 @@ static VALUE api_call(int argc, VALUE* argv, VALUE self){
  * Wraps the Windows API functions in a Ruby interface.
  */
 void Init_api(){
-   VALUE mWin32, cAPI, cCallback;
+   VALUE mWin32, cAPI, cCallback, cFunction;
    
    /* Modules and Classes */
    
@@ -493,6 +638,9 @@ void Init_api(){
    
    /* The API::Callback class encapsulates a Windows CALLBACK function */ 
    cCallback = rb_define_class_under(cAPI, "Callback", rb_cObject);
+
+   /* The API::Function class encapsulates a raw function pointer */
+   cFunction = rb_define_class_under(cAPI, "Function", cAPI);
    
    /* The API::Error class is raised if the constructor fails */
    cAPIError = rb_define_class_under(cAPI, "Error", rb_eRuntimeError);
@@ -507,7 +655,11 @@ void Init_api(){
    rb_define_method(cAPI, "initialize", api_init, -1);
    rb_define_method(cAPI, "call", api_call, -1);
 
+   /* Win32::API::Callback Instance Methods */
    rb_define_method(cCallback, "initialize", callback_init, -1);
+
+   /* Win32::API::Function Instance Methods */
+   rb_define_method(cFunction, "initialize", func_init, -1);
    
    /* The name of the DLL that exports the API function */
    rb_define_attr(cAPI, "dll_name", 1, 0);
@@ -534,6 +686,9 @@ void Init_api(){
       
    /* The return type, returned as a single character, P, L, I, V or B */
    rb_define_attr(cCallback, "return_type", 1, 0);
+
+   /* The numeric address of the function pointer */
+   rb_define_attr(cFunction, "address", 1, 0);
  
    /* Constants */
    

data/test/{tc_win32_api.rb → test_win32_api.rb}

@@ -1,5 +1,5 @@
 ############################################################################
-# tc_win32_api.rb
+# test_win32_api.rb
 # 
 # Test case for the Win32::API class. You should run this as Rake task,
 # i.e. 'rake test', instead of running it directly.
@@ -16,7 +16,7 @@ class TC_Win32_API < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal('1.0.6', API::VERSION)
+      assert_equal('1.1.0', API::VERSION)
    end
  
    def test_call
@@ -43,6 +43,12 @@ class TC_Win32_API < Test::Unit::TestCase
    def test_effective_function_name
       assert_respond_to(@api, :effective_function_name)
       assert_equal('GetCurrentDirectoryA', @api.effective_function_name)
+
+      @api = API.new('GetCurrentDirectoryA', 'LP')
+      assert_equal('GetCurrentDirectoryA', @api.effective_function_name)
+
+      @api = API.new('GetCurrentDirectoryW', 'LP')
+      assert_equal('GetCurrentDirectoryW', @api.effective_function_name)
    end
    
    def test_prototype

data/test/{tc_win32_api_callback.rb → test_win32_api_callback.rb}

@@ -1,5 +1,5 @@
 ############################################################################
-# tc_win32_api_callback.rb
+# test_win32_api_callback.rb
 # 
 # Test case for the Win32::API::Callback class. You should run this as Rake
 # task, i.e. 'rake test', instead of running it directly.
@@ -55,4 +55,4 @@ class TC_Win32_API_Callback < Test::Unit::TestCase
       @api_gwt  = nil
       @callback = nil
    end
-end
+end

data/test/test_win32_api_function.rb

@@ -0,0 +1,48 @@
+########################################################################
+# test_win32_api_function.rb
+#
+# Test case for the Win32::API::Function class. You should run these
+# tests via the 'rake test' task.
+########################################################################
+require 'test/unit'
+require 'win32/api'
+
+class TC_Win32_API_Function < Test::Unit::TestCase
+   def setup
+      @func = Win32::API::Function.new(123456789, 'LP', 'L')
+   end
+
+   def test_constructor
+      assert_nothing_raised{ Win32::API::Function.new(1) }
+      assert_nothing_raised{ Win32::API::Function.new(1, 'LL') }
+      assert_nothing_raised{ Win32::API::Function.new(1, 'LL', 'I') }
+   end
+   
+   def test_subclass
+      assert_kind_of(Win32::API, @func)
+      assert_respond_to(@func, :call)
+   end
+
+   def test_address
+      assert_respond_to(@func, :address)
+      assert_equal(123456789, @func.address)
+   end
+
+   def test_prototype
+      assert_respond_to(@func, :prototype)
+      assert_equal(['L', 'P'], @func.prototype)
+   end
+
+   def test_return_type
+      assert_respond_to(@func, :return_type)
+      assert_equal('L', @func.return_type)
+   end
+
+   def test_expected_errors
+      assert_raise(ArgumentError){ Win32::API::Function.new }
+   end
+
+   def teardown
+      @func = nil
+   end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win32-api
 version: !ruby/object:Gem::Version 
-  version: 1.0.6
+  version: 1.1.0
 platform: x86-mswin32-60
 authors: 
 - Daniel J. Berger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-18 00:00:00 -06:00
+date: 2008-06-12 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -25,14 +25,17 @@ extra_rdoc_files:
 - MANIFEST
 - ext/win32/api.c
 files: 
+- ext/extconf.rb
+- ext/win32
+- ext/win32/api.c
+- test/test_win32_api.rb
+- test/test_win32_api_callback.rb
+- test/test_win32_api_function.rb
 - lib/win32
 - lib/win32/api.so
-- test/tc_win32_api.rb
-- test/tc_win32_api_callback.rb
 - README
 - CHANGES
 - MANIFEST
-- ext/win32/api.c
 has_rdoc: true
 homepage: http://www.rubyforge.org/projects/win32utils
 post_install_message: 
@@ -44,7 +47,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.8.0
+      version: 1.8.2
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
@@ -59,6 +62,5 @@ rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: A superior replacement for Win32API
-test_files: 
-- test/tc_win32_api.rb
-- test/tc_win32_api_callback.rb
+test_files: []
+