ffi_wide_char 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19b32012cde9e95923464d15b12c156176c51c97e02a9d4d8aeed19d6a886839
-  data.tar.gz: '0772497956c010ad1be1d6cea9eaa586de0256f1c6b7bf303ea5ff13095f2dbc'
+  metadata.gz: f13487162d031d2b591d6e7ef446edce77c9b4e635499944448a1f374d735240
+  data.tar.gz: 83e493aa9e66d21f8738ed895e2b55b4bcd1cc25ce291440ce9ada8454a340cc
 SHA512:
-  metadata.gz: ecd7aa2746e6ba7e3ae41d13c0237971a15aa156f2ad2489c6e2fd2bc9366195c2a4f0cbfdb18e536e828b85ff6bdfbacfa5511ae3032720265cdbadd77600d7
-  data.tar.gz: bafdddf658523047680c82d129fead2899cfcc1d3b98bb8e4f9c877cd8b8de8f89b74fc87c4c67ab50df78379330088fe688d1694f43337b5fcf20a981913a41
+  metadata.gz: a9d0de60039102974f50dcc2a8648d12a03afe67c0653304cac26217b57e8a067dd7289f00eae86f86cfe09c82148e0fd95dd2ef4dce36474fd8ed8d42a1489a
+  data.tar.gz: 75b9169991423761bdd3ba66119a41e41867798f19fa5696733a57ce7cc157ca83578d4b9b0836617df9312ce6f4d86e3df03fc8c228da17d7f66c53b53c9c1b

data/README.md

@@ -0,0 +1,64 @@
+# FfiWideChar [![Build Status](https://travis-ci.org/nthachus/ffi_wide_char.svg?branch=master)](https://travis-ci.org/nthachus/ffi_wide_char)
+
+A Ruby gem helper for FFI binding libraries to convert from/to C native `wchar_t` wide-string.
+
+It provides 2 methods: `read_wide_string` and `to_wide_string` for converting.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ffi_wide_char'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ffi_wide_char
+
+## Usage
+
+Example of calling native library functions using `wide-string` type:
+
+```ruby
+require 'ffi_wide_char'
+
+# Unicode Popup Dialog
+module Win
+  extend FFI::Library
+
+  ffi_lib 'user32'
+  ffi_convention :stdcall
+
+  attach_function :message_box, :MessageBoxW, %i[pointer buffer_in buffer_in int], :int
+end
+
+msg = FfiWideChar.to_wide_string('a中Я')
+Win.message_box(nil, msg, msg, 0)
+
+# Convert multibyte to wide-string
+ptr = FFI::MemoryPointer.new(:char, 16)
+FfiWideChar::LibC.mbstowcs(ptr, '©Ðõ'.encode('filesystem'), 4)
+
+str = FfiWideChar.read_wide_string ptr
+puts str.encode('UTF-8')
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rake` to run the tests.
+You can also run `irb -r bundler/setup -r ffi_wide_char` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nthachus/ffi_wide_char.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/ffi_wide_char.rb

@@ -1,89 +1,70 @@
 # frozen_string_literal: true
 
-require 'ffi'
-
-require 'ffi_wide_char/api'
 require 'ffi_wide_char/version'
+require 'ffi_wide_char/api'
 
 module FfiWideChar
-  class InvalidMultibyteCharError < StandardError; end
-  class UnsupportedWCharEncodingError < StandardError; end
+  class Error < StandardError; end
 
-  DEFAULT_ENC = 'UTF-16LE'
-  ENCODINGS   = {
-    "!\x00@\x00\x00\x00" => DEFAULT_ENC,
-    "\x00!\x00@\x00\x00" => 'UTF-16BE',
-    "!\x00\x00\x00@\x00" => 'UTF-32LE',
-    "\x00\x00\x00!\x00\x00" => 'UTF-32BE'
+  ENCODINGS = {
+    'UTF-16LE' => "!\x00@\x00\x00\x00",
+    'UTF-16BE' => "\x00!\x00@\x00\x00",
+    'UTF-32LE' => "!\x00\x00\x00@\x00",
+    'UTF-32BE' => "\x00\x00\x00!\x00\x00"
   }.freeze
 
-  W_CHAR_ENC  = nil
-  W_CHAR_SIZE = 2
-  W_CHAR_FUNC = :get_uint16
-
   # All methods in this block are static
   class << self
     # Detect `wchar_t` encoding.
-    # @return [String] Name of the wide-string encoding.
-    def detect_encoding
-      return W_CHAR_ENC if W_CHAR_ENC
-
-      ptr = FFI::MemoryPointer.new(:uint8, 6)
-      ret = LibC.mbstowcs(ptr, '!@', 3)
-      raise InvalidMultibyteCharError unless ret.is_a?(Numeric) && ret >= 0
-
-      enc = ENCODINGS[str = ptr.get_bytes(0, 6)]
-      raise UnsupportedWCharEncodingError, str.inspect unless enc
-
-      redefine_consts enc
+    # @return [String] Encoding name of the wide-string .
+    def encoding
+      @encoding ||=
+        begin
+          ptr = FFI::MemoryPointer.new(:char, 12)
+          rc  = LibC.mbstowcs(ptr, '!@', 3)
+          raise Error, 'Invalid multibyte character' unless rc.is_a?(Integer) && rc >= 0
+
+          str = ptr.get_bytes(0, 6)
+          enc = ENCODINGS.key(str)
+          raise Error, "Unsupported wide-character encoding #{str.inspect}" unless enc
+
+          enc
+        end
     end
 
-    # Look for a null terminating characters; if found, read up to that null (exclusive)
-    # @param ptr [Pointer] A wide-string pointer.
+    alias detect_encoding encoding
+
+    # Look for a null-terminated characters; if found, read up to that null (exclusive)
+    # @param ptr [FFI::Pointer] A wide-string pointer.
     # @return [String] Decoded wide-string.
     def read_wide_string(ptr)
-      return nil unless ptr && (get_object_attr(ptr, :address) || 0) != 0
+      return nil if !ptr.respond_to?(:null?) || ptr.null?
+
+      @size ||= encoding.include?('32') ? 4 : 2
+      @func ||= @size == 4 ? :get_int32 : :get_int16
 
       len = get_wide_string_len ptr
-      ptr.get_bytes(0, len).force_encoding(W_CHAR_ENC || DEFAULT_ENC)
+      ptr.get_bytes(0, len).force_encoding(encoding)
     end
 
     # Convert a Ruby string into a C native wide-string.
     # @param str [String] A Ruby string.
     # @return [String] C native wide-string.
     def to_wide_string(str)
-      str ? str.encode(W_CHAR_ENC || DEFAULT_ENC) : str
+      str ? str.encode(encoding) : str
     end
 
     private
 
-    # @param enc [String]
-    # @return [String]
-    def redefine_consts(enc)
-      [:W_CHAR_ENC, :W_CHAR_SIZE, :W_CHAR_FUNC].each { |name| send :remove_const, name }
-
-      const_set :W_CHAR_ENC, enc
-      const_set :W_CHAR_SIZE, enc.include?('32') ? 4 : 2
-      const_set :W_CHAR_FUNC, W_CHAR_SIZE == 4 ? :get_int32 : :get_uint16
-
-      enc
-    end
-
-    # @param obj [Object]
-    # @param name [Symbol]
-    # @return [Object]
-    def get_object_attr(obj, name)
-      obj.respond_to?(name) ? obj.send(name) : nil
-    end
-
-    # @param ptr [Pointer]
+    # Detect wide-string length in bytes
+    # @param ptr [FFI::Pointer]
     # @return [Integer]
     def get_wide_string_len(ptr)
-      sz = get_object_attr(ptr, :size)
-      sz -= W_CHAR_SIZE if sz
+      sz = ptr.size
+      sz -= @size if sz
 
       len = 0
-      len += W_CHAR_SIZE while (!sz || len < sz) && ptr.send(W_CHAR_FUNC, len) != 0
+      len += @size while (!sz || len < sz) && ptr.send(@func, len) != 0
 
       len
     end

data/lib/ffi_wide_char/api.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
 
+require 'ffi'
+
 module FfiWideChar
   module LibC
     extend FFI::Library
     ffi_lib FFI::Library::LIBC
 
-    # Converts a string of multibyte characters to a wide character array
-    # size_t mbstowcs (wchar_t *wstring, const char *string, size_t size)
+    # @!scope class
+    # @!method mbstowcs(dest, src, size)
+    #   Converts a string of multibyte characters to a wide character array
+    #   @param dest [FFI::Pointer]  of wchar_t*
+    #   @param src [String]
+    #   @param size [Integer] Max number of :wchar_t characters to write to dest
+    #   @return [Integer] Number of :wchar_t written to dest (w/o null-terminated), or -1 if error
     attach_function :mbstowcs, [:pointer, :string, :size_t], :size_t
   end
 end

data/lib/ffi_wide_char/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FfiWideChar
-  VERSION = '1.0.2'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi_wide_char
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Thach Nguyen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -88,6 +88,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
+- README.md
 - lib/ffi_wide_char/api.rb
 - lib/ffi_wide_char/version.rb
 - lib/ffi_wide_char.rb
@@ -110,8 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Provides methods to convert from/to FFI wide-string.