windows-pr 0.9.0 → 0.9.1

data/CHANGES

@@ -1,3 +1,11 @@
+= 0.9.1 - 28-Jul-2008
+* Yet another refactoring of the multi_to_wide and wide_to_multi helper
+  methods in the Windows::Unicode module. In addition to a bug fix, they
+  now raise an ArgumentError if they fail.
+* Yet another tweak to get_last_error in the Windows::Error module. It now
+  always uses the explicit ANSI version of the FormatMessage function.
+* Added tests for the multi_to_wide and wide_to_multi helper methods.
+
 = 0.9.0 - 26-Jul-2008
 * The process of converting prototypes from 'P' to 'S' has begun. This
   means that this library now requires win32-api 1.2.0 or later.

data/lib/windows/error.rb

@@ -418,10 +418,10 @@ module Windows
       # returns a human readable string.
       #
       def get_last_error(err_num = GetLastError.call)
-         buf   = $KCODE == 'UTF8' ? 0.chr * 520 : 0.chr * 260
+         buf   = 0.chr * 260
          flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY        
-         FormatMessage.call(flags, 0, err_num, 0, buf, buf.size, 0)
-         buf.split(0.chr).join[ /^[^\0\r\n]*/ ] rescue 'Unknown error'       
+         FormatMessageA.call(flags, 0, err_num, 0, buf, buf.size, 0)
+         buf.strip      
       end
       
       # Macros from WinError.h

data/lib/windows/unicode.rb

@@ -1,9 +1,11 @@
 require 'windows/api'
 require 'windows/msvcrt/string'
+require 'windows/error'
 
 module Windows
    module Unicode
       include Windows::MSVCRT::String
+      include Windows::Error
       
       API.auto_namespace = 'Windows::Unicode'
       API.auto_constant  = true
@@ -95,24 +97,16 @@ module Windows
             encoding = ($KCODE == 'UTF8') ? CP_UTF8 : CP_ACP
          end
          
-         buf = ' ' * strlen(string) * 2
-         
-         int = MultiByteToWideChar(
-            encoding,
-            0,
-            string,
-            strlen(string),
-            buf,
-            strlen(buf)
-         )
+         int = MultiByteToWideChar(encoding, 0, string, -1, nil, 0)
          
+         # Trailing nulls are retained
          if int > 0
-            dest = ' ' * int * 2
-            wcsncpy(dest, buf, int)
-            dest
+            buf = ' ' * int * 2
+            MultiByteToWideChar(encoding, 0, string, -1, buf, int)
+            buf
          else
-            string
-         end
+            raise ArgumentError, get_last_error
+         end         
       end
       
       # Maps a wide character string to a new character string using the
@@ -121,34 +115,24 @@ module Windows
       # 
       # If the function fails it simply returns the string as-is.
       # 
-      def wide_to_multi(string, encoding=nil)
-         return nil unless string
-         raise TypeError unless string.is_a?(String)
+      def wide_to_multi(wstring, encoding=nil)
+         return nil unless wstring
+         raise TypeError unless wstring.is_a?(String)
          
          unless encoding
             encoding = ($KCODE == 'UTF8') ? CP_UTF8 : CP_ACP
          end
-         
-         buf = ' ' * wcslen(string)
-
-         int = WideCharToMultiByte(
-            encoding,
-            0,
-            string,
-            wcslen(string),
-            buf,
-            strlen(buf),
-            0,
-            0
-         )
 
+         int = WideCharToMultiByte(encoding, 0, wstring, -1, 0, 0, nil, nil)
+         
+         # Trailing nulls are stripped
          if int > 0
-            dest = ' ' * int
-            strncpy(dest, buf, int)
-            dest
+            buf = ' ' * int
+            WideCharToMultiByte(encoding, 0, wstring, -1, buf, strlen(buf), nil, nil)
+            buf[ /^[^\0]*/ ]
          else
-            string
-         end
+            raise ArgumentError, get_last_error
+         end         
       end
    end
 end

data/test/tc_unicode.rb

@@ -6,45 +6,73 @@
 require "windows/unicode"
 require "test/unit"
 
-class UnicodeFoo
-   include Windows::Unicode
-end
-
 class TC_Windows_Unicode < Test::Unit::TestCase
-   def setup
-      @foo = UnicodeFoo.new
-   end
+   include Windows::Unicode
 
    def test_numeric_constants
-      assert_equal(0, UnicodeFoo::CP_ACP)
-      assert_equal(1, UnicodeFoo::CP_OEMCP)
-      assert_equal(2, UnicodeFoo::CP_MACCP)
-      assert_equal(3, UnicodeFoo::CP_THREAD_ACP)
-      assert_equal(42, UnicodeFoo::CP_SYMBOL)
-      assert_equal(65000, UnicodeFoo::CP_UTF7)
-      assert_equal(65001, UnicodeFoo::CP_UTF8)
+      assert_equal(0, CP_ACP)
+      assert_equal(1, CP_OEMCP)
+      assert_equal(2, CP_MACCP)
+      assert_equal(3, CP_THREAD_ACP)
+      assert_equal(42, CP_SYMBOL)
+      assert_equal(65000, CP_UTF7)
+      assert_equal(65001, CP_UTF8)
 
-      assert_equal(0x00000001, UnicodeFoo::MB_PRECOMPOSED)
-      assert_equal(0x00000002, UnicodeFoo::MB_COMPOSITE)
-      assert_equal(0x00000004, UnicodeFoo::MB_USEGLYPHCHARS)
-      assert_equal(0x00000008, UnicodeFoo::MB_ERR_INVALID_CHARS)
+      assert_equal(0x00000001, MB_PRECOMPOSED)
+      assert_equal(0x00000002, MB_COMPOSITE)
+      assert_equal(0x00000004, MB_USEGLYPHCHARS)
+      assert_equal(0x00000008, MB_ERR_INVALID_CHARS)
 
-      assert_equal(0x00000200, UnicodeFoo::WC_COMPOSITECHECK)
-      assert_equal(0x00000010, UnicodeFoo::WC_DISCARDNS)
-      assert_equal(0x00000020, UnicodeFoo::WC_SEPCHARS)
-      assert_equal(0x00000040, UnicodeFoo::WC_DEFAULTCHAR)
-      assert_equal(0x00000400, UnicodeFoo::WC_NO_BEST_FIT_CHARS)
+      assert_equal(0x00000200, WC_COMPOSITECHECK)
+      assert_equal(0x00000010, WC_DISCARDNS)
+      assert_equal(0x00000020, WC_SEPCHARS)
+      assert_equal(0x00000040, WC_DEFAULTCHAR)
+      assert_equal(0x00000400, WC_NO_BEST_FIT_CHARS)
    end
 
    def test_method_constants
-      assert_not_nil(UnicodeFoo::GetTextCharset)
-      assert_not_nil(UnicodeFoo::GetTextCharsetInfo)
-      assert_not_nil(UnicodeFoo::IsDBCSLeadByte)
-      assert_not_nil(UnicodeFoo::IsDBCSLeadByteEx)
-      assert_not_nil(UnicodeFoo::IsTextUnicode)
-      assert_not_nil(UnicodeFoo::MultiByteToWideChar)
-      assert_not_nil(UnicodeFoo::TranslateCharsetInfo)
-      assert_not_nil(UnicodeFoo::WideCharToMultiByte)
+      assert_respond_to(self, :GetTextCharset)
+      assert_respond_to(self, :GetTextCharsetInfo)
+      assert_respond_to(self, :IsDBCSLeadByte)
+      assert_respond_to(self, :IsDBCSLeadByteEx)
+      assert_respond_to(self, :IsTextUnicode)
+      assert_respond_to(self, :MultiByteToWideChar)
+      assert_respond_to(self, :TranslateCharsetInfo)
+      assert_respond_to(self, :WideCharToMultiByte)
+   end
+
+   def test_multi_to_wide
+      assert_respond_to(self, :multi_to_wide)
+      assert_equal("\000\000", multi_to_wide(''))
+      assert_equal("h\000e\000l\000l\000o\000\000\000", multi_to_wide('hello'))
+      assert_equal("\316\000\" \316\000\273\000\316\000\273\000\316\000\254\000\317\000\222\001\000\000", multi_to_wide("Ελλάσ"))
+   end
+   
+   def test_multi_to_wide_with_encoding
+      assert_equal("h\000e\000l\000l\000o\000\000\000", multi_to_wide('hello', CP_UTF8))
+      assert_equal("\225\003\273\003\273\003\254\003\303\003\000\000", multi_to_wide("Ελλάσ", CP_UTF8))
+   end
+   
+   def test_multi_to_wide_expected_errors
+      assert_raise(TypeError){ multi_to_wide(1) }
+      assert_raise(TypeError){ multi_to_wide([]) }
+   end
+   
+   def test_wide_to_multi
+      assert_respond_to(self, :wide_to_multi)
+      assert_equal('', wide_to_multi("\000\000"))
+      assert_equal('hello', wide_to_multi("h\000e\000l\000l\000o\000\000\000"))
+      assert_equal("Ελλάσ", wide_to_multi("\316\000\" \316\000\273\000\316\000\273\000\316\000\254\000\317\000\222\001\000\000"))
+   end
+   
+   def test_wide_to_multi_with_encoding
+      assert_equal('hello', wide_to_multi("h\000e\000l\000l\000o\000\000\000"), CP_UTF8)
+      assert_equal("Ελλάσ", wide_to_multi("\225\003\273\003\273\003\254\003\303\003\000\000", CP_UTF8))
+   end
+   
+   def test_wide_to_multi_expected_errors
+      assert_raise(TypeError){ wide_to_multi(1) }
+      assert_raise(TypeError){ wide_to_multi([]) }      
    end
 
    def teardown

data/windows-pr.gemspec

@@ -2,8 +2,8 @@ require "rubygems"
 
 spec = Gem::Specification.new do |gem|
    gem.name        = "windows-pr"
-   gem.version     = "0.9.0"
-   gem.author      = "Daniel J. Berger"
+   gem.version     = "0.9.1"
+   gem.authors     = ["Daniel J. Berger", "Park Heesob"]
    gem.email       = "djberg96@gmail.com"
    gem.homepage    = "http://www.rubyforge.org/projects/win32utils"
    gem.rubyforge_project = "win32utils"

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification 
 name: windows-pr
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
 - Daniel J. Berger
+- Park Heesob
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-07-26 00:00:00 -06:00
+date: 2008-07-29 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency