windows-pr 1.2.4 → 1.2.5

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/win32-api.gemspec

@@ -0,0 +1,27 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'win32-api'
+  spec.version    = '1.6.0'
+  spec.authors    = ['Daniel J. Berger', 'Park Heesob', 'Hiroshi Hatake']
+  spec.license    = 'Artistic 2.0'
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'http://github.com/djberg96/win32-api'
+  spec.summary    = 'A superior replacement for Win32API'
+  spec.test_files = Dir['test/test*']
+  spec.extensions = ['ext/extconf.rb']
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  spec.required_ruby_version = '>= 1.8.2'
+  spec.extra_rdoc_files = ['README', 'CHANGES', 'MANIFEST', 'ext/win32/api.c']
+
+  spec.add_development_dependency('test-unit', '>= 2.5.0')
+  spec.add_development_dependency('rake')
+
+  spec.description = <<-EOF
+    The Win32::API library is meant as a replacement for the Win32API
+    library that ships as part of the standard library. It contains several
+    advantages over Win32API, including callback support, raw function
+    pointers, an additional string type, and more.
+  EOF
+end

data/vendor/bundle/ruby/2.2.0/gems/windows-api-0.4.4/CHANGES

@@ -0,0 +1,68 @@
+== 0.4.4 - 18-Mar-2015
+* Removed a duplicate hash entry. Thanks go to Baptiste Courtois for the spot.
+* Added some specialized test tasks.
+
+== 0.4.3 - 20-Oct-2014
+* Updates to the gemspec and Rakefile.
+
+== 0.4.2 - 13-Jul-2012
+* Fixed a bug in the way MSVCRT_DLL is set. Thanks go to Park Heesob for
+  the spot and patch.
+* Some minor test refactoring and cosmetic udpates.
+
+== 0.4.1 - 27-Jan-2012
+* Switched Config to RbConfig to silence 1.9 warnings. Thanks go to
+  Cameron Cox for the patch.
+* Some updates to the README, Rakefile, gemspec and test files.
+
+== 0.4.0 - 18-Oct-2009
+* Methods that begin with an underscore, such as _umask(), are now preserved.
+  A method alias is also created without an underscore, e.g. umask().
+* Added the gem task to the Rakefile.
+* Minor updates to the gemspec.
+
+== 0.3.1 - 18-Aug-2009
+* Changed license to Artistic 2.0.
+* Some gemspec updates, including the addition of a license, an updated
+  description and a dependency update.
+* One test update for VC++ 9.
+
+== 0.3.0 - 1-Feb-2009
+* No longer explicitly checks for an error in the constructor. It lets the
+  underlying Win32::API library deal with it.
+* More dynamic handling and setting of the MSVCRT_DLL variable.
+* Added a WideString implementation. Internal use only.
+
+== 0.2.4 - 18-Jul-2008
+* Eliminated unnecessary LoadLibrary() attempts for functions that explicitly
+  end with an 'A' or 'W', and all MSVCRT functions, since they have no 'A'
+  or 'W' equivalent.
+* Replaced all of the attr_reader's with a delegation scheme using Forwardable.
+  All Win32::API functions now delegate to the internally stored Win32::API
+  object instead of reimplementing them. This change also fixed a bug where
+  the effective_function_name method did not work properly.
+* Added more tests, and fixed one assertion that was wrong (the prototype).
+* Some documentation additions.
+
+== 0.2.3 - 26-Apr-2008
+* Improved API.auto_constant and API.auto_method handling for functions that
+  start with a lower case character or an underscore.
+
+== 0.2.2 - 17-Apr-2008
+* Added the Windows::MSVCRT_DLL constant so that users can specify MSVCRT_DLL
+  for the DLL name and it will do the right thing, instead of having to worry
+  about specifying a DLL or associated DLL.
+
+== 0.2.1 - 10-Feb-2008
+* Added support for long data type names, e.g. 'DWORD' instead of 'L', for
+  both the prototype and return type.
+
+== 0.2.0 - 20-Sep-2007
+* Now requires the win32-api library.
+* Replaced class variables with class instance variables to prevent conflicts.
+
+== 0.1.1 - 25-May-2007
+* Fixed a void parameter bug.
+
+== 0.1.0 - 24-May-2007
+* Initial release

data/vendor/bundle/ruby/2.2.0/gems/windows-api-0.4.4/MANIFEST

@@ -0,0 +1,9 @@
+* CHANGES
+* MANIFEST
+* README
+* Rakefile
+* windows-api.gemspec
+* lib/windows/api.rb
+* lib/windows/wide_string.rb
+* test/test_windows_api.rb
+* test/test_wide_string.rb

data/vendor/bundle/ruby/2.2.0/gems/windows-api-0.4.4/README

@@ -0,0 +1,96 @@
+== Description
+   This is a wrapper for Win32::API that simplifies various idioms typically
+   used by people who use Win32::API.
+
+== Synopsis
+   require 'windows/api'
+   include Windows
+   
+   # Defaults to 'V' prototype, 'L' return type and 'kernel32' library
+   GetVersion = API.new('GetVersion')
+   
+   # Defaults to 'L' return type and 'kernel32' library
+   CloseHandle = API.new('CloseHandle', 'L')
+   
+   # Defaults to 'kernel32' library
+   GetWindowsDirectory = API.new('GetWindowsDirectory', 'LI', 'I')
+   
+   # Explicitly state every argument
+   GetComputerNameEx = API.new('GetComputerNameEx', 'PPP', 'I', 'kernel32')
+   
+   # Use long data type names
+   GetUserName = API.new('GetUserName',['LPTSTR','LPDWORD'],'BOOL','advapi32')
+   
+   # Attributes for possible inspection
+   puts GetVersion.dll_name      # 'kernel32'
+   puts GetVersion.function_name # 'GetVersion'
+   puts GetVersion.prototype     # ['V']
+   puts GetVersion.return_type   # 'L'
+
+   # Automatic method generation
+
+   # This code....
+   module Windows
+     module Foo
+       API.auto_namespace = 'Windows::Foo'
+       API.auto_constant  = true
+       API.auto_method    = true
+       API.auto_unicode   = true
+         
+       API.new('GetComputerName', 'PP', 'B')
+     end
+   end
+
+   # Is the same as this code...
+   module Windows
+     module Foo
+       GetComputerName  = Win32API.new('kernel32', 'GetComputerName', 'PP', 'I')
+       GetComputerNameA = Win32API.new('kernel32', 'GetComputerNameA', 'PP', 'I')
+       GetComputerNameW = Win32API.new('kernel32', 'GetComputerNameW', 'PP', 'I')
+
+       def GetComputerName(p1, p2)
+         GetComputerName.call(p1, p2) != 0
+       end
+
+       def GetComputerNameA(p1, p2)
+         GetComputerName.call(p1, p2) != 0
+       end
+
+       def GetComputerNameW(p1, p2)
+         GetComputerName.call(p1, p2) != 0
+       end
+     end
+   end
+
+== Advantages over plain Win32::API
+   * Automatic constant generation.
+   * Automatic definition of ANSI and Unicode method wrappers, including
+     special handling for boolean methods.
+   * Ability to use more familiar Windows data types, e.g. DWORD.
+   * Automatic handling of msvcrt vs msvcrXX via MSVCRT_DLL constant.
+
+== Other Stuff
+   There's also a WideString class for easily creating wide strings for
+   Ruby 1.8.x. Ruby 1.9.x can use Ruby's encoding methods to accomplish
+   the same effect, however.
+
+== More documentation
+   See the RDoc documentation, which should have been automatically generated
+   if you installed this as a gem.
+
+== Future Plans
+   I have no future plans for this library other than bug fixes. You should
+   use FFI instead of win32-api for all projects where possible.
+
+== Bugs
+   None that I'm aware of. Please submit any bugs to the project page at
+   https://github.com/djberg96/windows-api.
+
+== Copyright
+   (C) 2007-2015, Daniel J. Berger
+
+== License
+   Artistic 2.0
+
+== Author
+   Daniel Berger

data/vendor/bundle/ruby/2.2.0/gems/windows-api-0.4.4/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+
+CLEAN.include("**/*.gem", "**/*.rbc")
+
+namespace :gem do
+  desc 'Create the windows-api gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('windows-api.gemspec'))
+    if Gem::VERSION < "2.0"
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
+  end
+
+  desc 'Install the windows-api gem'
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install -l #{file}"
+  end
+end
+
+Rake::TestTask.new do |test|
+  test.warning = true
+  test.verbose = true
+end
+
+namespace :test do
+  desc "Test the core windows-api library"
+  Rake::TestTask.new(:api) do |t|
+    t.warning = true
+    t.verbose = true
+    t.test_files = FileList['test/test_windows_api.rb']
+  end
+
+  desc "Test the wide string methods"
+  Rake::TestTask.new(:wide) do |t|
+    t.warning = true
+    t.verbose = true
+    t.test_files = FileList['test/test_wide_string.rb']
+  end
+end
+
+task :default => :test

data/vendor/bundle/ruby/2.2.0/gems/windows-api-0.4.4/lib/windows/api.rb

@@ -0,0 +1,503 @@
+require 'win32/api'
+require 'rbconfig'
+require 'forwardable'
+include RbConfig
+
+# The Windows module serves as a namespace only
+module Windows
+
+  # With Microsoft Visual C++ 8 and later users should use the associated
+  # DLL instead of msvcrt directly, if possible.
+  if CONFIG['host_os'].split('_')[1]
+    if CONFIG['host_os'].split('_')[1].to_i >= 80
+      MSVCRT_DLL = 'msvcr' + CONFIG['host_os'].split('_')[1]
+    else
+      MSVCRT_DLL = 'msvcrt'
+    end
+  else
+    MSVCRT_DLL = 'msvcrt'
+  end
+
+  # Wrapper around the Win32::API class
+  class API
+    extend Forwardable
+
+    # The version of the windows-api library
+    VERSION = '0.4.4'
+
+    # The methods from Win32::API are delegated to the appropriate object
+    def_delegators(:@api, :function_name, :dll_name, :prototype)
+    def_delegators(:@api, :return_type, :effective_function_name)
+
+    private
+
+    # Verbose data types that can be used instead of single letters
+    DATA_TYPES = {
+      'ATOM'         => 'I',
+      'BOOL'         => 'B',
+      'BOOLEAN'      => 'B',
+      'BYTE'         => 'I',
+      'CALLBACK'     => 'K',
+      'CHAR'         => 'I',
+      'COLORREF'     => 'L',
+      'DWORD'        => 'L',
+      'DWORDLONG'    => 'L',
+      'DWORD_PTR'    => 'P',
+      'DWORD32'      => 'I',
+      'DWORD64'      => 'L',
+      'HACCEL'       => 'L',
+      'HANDLE'       => 'L',
+      'HBITMAP'      => 'L',
+      'HBRUSH'       => 'L',
+      'HCOLORSPACE'  => 'L',
+      'HCONV'        => 'L',
+      'HDC'          => 'L',
+      'HFILE'        => 'I',
+      'HFONT'        => 'L',
+      'HINSTANCE'    => 'L',
+      'HKEY'         => 'L',
+      'HLOCAL'       => 'L',
+      'HMENU'        => 'L',
+      'HMODULE'      => 'L',
+      'HRESULT'      => 'L',
+      'HWND'         => 'L',
+      'INT'          => 'I',
+      'INT_PTR'      => 'P',
+      'INT32'        => 'I',
+      'INT64'        => 'L',
+      'LANGID'       => 'I',
+      'LCID'         => 'L',
+      'LCTYPE'       => 'L',
+      'LONG'         => 'L',
+      'LONGLONG'     => 'L',
+      'LONG_PTR'     => 'P',
+      'LONG32'       => 'L',
+      'LONG64'       => 'L',
+      'LPARAM'       => 'P',
+      'LPBOOL'       => 'P',
+      'LPBYTE'       => 'P',
+      'LPCOLORREF'   => 'P',
+      'LPCSTR'       => 'P',
+      'LPCTSTR'      => 'P',
+      'LPCVOID'      => 'L',
+      'LPCWSTR'      => 'P',
+      'LPDWORD'      => 'P',
+      'LPHANDLE'     => 'P',
+      'LPINT'        => 'P',
+      'LPLONG'       => 'P',
+      'LPSTR'        => 'P',
+      'LPTSTR'       => 'P',
+      'LPVOID'       => 'L',
+      'LPWORD'       => 'P',
+      'LPWSTR'       => 'P',
+      'LRESULT'      => 'P',
+      'PBOOL'        => 'P',
+      'PBOOLEAN'     => 'P',
+      'PBYTE'        => 'P',
+      'PHKEY'        => 'P',
+      'SC_HANDLE'    => 'L',
+      'SC_LOCK'      => 'L',
+      'SERVICE_STATUS_HANDLE' => 'L',
+      'SHORT'        => 'I',
+      'SIZE_T'       => 'P',
+      'TCHAR'        => 'L',
+      'UINT'         => 'I',
+      'UINT_PTR'     => 'P',
+      'UINT32'       => 'I',
+      'UINT64'       => 'L',
+      'ULONG'        => 'L',
+      'ULONGLONG'    => 'L',
+      'ULONG_PTR'    => 'P',
+      'ULONG32'      => 'L',
+      'ULONG64'      => 'L',
+      'USHORT'       => 'I',
+      'USN'          => 'L',
+      'WINAPI'       => 'L',
+      'WORD'         => 'I'
+    }
+
+    public
+
+    @auto_constant  = false
+    @auto_method    = false
+    @auto_unicode   = false
+    @auto_namespace = nil
+
+    # Returns the value of the @auto_constant class instance variable. The
+    # default is nil, i.e. none. See the Windows::API.auto_constant=
+    # documentation for more information.
+    #
+    def self.auto_constant
+      @auto_constant
+    end
+
+    # Automatically sets a constant to match the function name.
+    #
+    # The standard practice for defining Windows::API objects is to use
+    # a constant that matches the function name. For example, this is a
+    # typical idiom:
+    #
+    #    module Windows
+    #       module File
+    #          GetFileAttributes = API.new('GetFileAttributes', 'P','L')
+    #       end
+    #    end
+    #
+    # With the API.auto_constant value set to true you can avoid the
+    # assignment step and the matching constant name will be automatically
+    # set for you in the namespace defined in API.auto_namespace. In other
+    # words, this example is identical to the one above:
+    #
+    #    module Windows
+    #       module File
+    #          API.auto_constant  = true
+    #          API.auto_namespace = 'Windows::File'
+    #          API.new('GetFileAttributes', 'P', 'L')
+    #       end
+    #    end
+    #
+    # If the auto_constant class variable is set to true, but no
+    # auto_namespace is set, an error will be raised. Note that the
+    # namespace must refer to an existing module (not a class).
+    #--
+    # TODO: If there's a way to automatically grab the namespace internally,
+    # nesting and all, I'd love to know the solution.
+    #
+    def self.auto_constant=(bool)
+      @auto_constant = bool
+    end
+
+    # Returns the value of the auto_namespace class instance variable. Used
+    # in conjunction with API.auto_constant and/or API.auto_method.
+    #
+    def self.auto_namespace
+      @auto_namespace
+    end
+
+    # Sets the value of the auto_namespace class nstance variable. The
+    # default is nil, i.e. none. Use in conjunction with the auto_constant
+    # and/or auto_method class variables, this method will automatically set
+    # a constant and/or method in +namespace+ equal to the function name set
+    # in the constructor.
+    #
+    # The +namespace+ must refer to an existing module, not a class.
+    #
+    def self.auto_namespace=(namespace)
+      @auto_namespace = namespace
+    end
+
+    # Returns the value of the auto_method class instance variable. Used in
+    # conjunction with auto_unicode.  See API.auto_method= for more
+    # information.
+    #
+    def self.auto_method
+      @auto_method
+    end
+
+    # If this option is set to true then a corresponding method is
+    # automatically generated when you create a new Windows::API object.
+    #
+    # For example, instead of doing this:
+    #
+    #    module Windows
+    #       module File
+    #          GetFileAttributes = API.new('GetFileAttributes', 'P', 'L')
+    #
+    #          def GetFileAttributes(x)
+    #             GetFileAttributes.call(x)
+    #          end
+    #       end
+    #    end
+    #
+    # You can do this, and have the method autogenerated for you.
+    #
+    #    module Windows
+    #       module File
+    #          API.auto_namespace = 'Windows::File'
+    #          API.auto_constant  = true
+    #          API.auto_method    = true
+    #          API.new('GetFileAttributes', 'P', 'L')
+    #       end
+    #    end
+    #
+    #    include Windows::File
+    #    GetFileAttributes('C:/test.txt') # vs. GetFileAttributes.call
+    #
+    # If the Windows::API object is declared to be a boolean in the
+    # constructor, then the method definition automatically includes a
+    # '!= 0' clause at the end of the call. That way, you can do
+    # 'if SomeMethod(x)' instead of having to do 'if SomeMethod(x) != 0',
+    # and it will do the right thing.
+    #
+    # If the API.auto_unicode option is also set to true, then you will
+    # get three method definitions. The standard function name, the explicit
+    # ANSI ('A') version and the explicit Unicode/wide version ('W'). The
+    # exception to this rule is that the explicit ANSI and Unicode methods
+    # will NOT be generated if the function passed to the constructor
+    # already ends with 'A' or 'W'.
+    #
+    def self.auto_method=(bool)
+      @auto_method = bool
+    end
+
+    # Returns the value of the auto_unicode class instance variable. This
+    # is used in conjunction with the auto_method and/or auto_constant class
+    # variables. Not significant if neither of those variables are set.
+    #
+    def self.auto_unicode
+      @auto_unicode
+    end
+
+    # If set to true, and the auto_constant variable is set, then the
+    # automatic constant generation will generate the explicit ANSI ('A')
+    # and Unicode/wide ('W') versions of the function passed to the
+    # constructor, if such versions exist.  Likewise, if the the
+    # auto_method variable is set, then explicit ANSI and Unicode methods
+    # are generated.
+    #
+    # Here's a typical idiom:
+    #
+    # module Windows
+    #    module Path
+    #       API.auto_namespace = Windows::Path
+    #       API.auto_constant = true
+    #       API.new('shlwapi', 'PathAddBackslash', 'P', 'P')
+    #       API.new('shlwapi', 'PathAddBackslashA', 'P', 'P')
+    #       API.new('shlwapi', 'PathAddBackslashW', 'P', 'P')
+    #    end
+    # end
+    #
+    # That can be reduced to this:
+    #
+    # module Windows
+    #    module Path
+    #       API.auto_namespace = Windows::Path
+    #       API.auto_constant = true
+    #       API.auto_unicode  = true
+    #       API.new('shlwapi', 'PathAddBackslash', 'P', 'P')
+    #    end
+    # end
+    #
+    # This value is ignored if the function passed to the constructor
+    # already ends with an 'A' or 'W'.
+    #
+    def self.auto_unicode=(bool)
+      @auto_unicode = bool
+    end
+
+    # call-seq:
+    #    API.new(func, proto='V', rtype='L', dll='kernel32')
+    #
+    # Creates and returns a new Windows::API object.  The +func+ is the
+    # name of the Windows function.
+    #
+    # The +proto+ is the function prototype for +func+.  This can be a
+    # string or an array of characters.  The possible valid characters
+    # are 'I' (integer), 'B' (BOOL), 'L' (long), 'V' (void), or 'P' (pointer).
+    # The default is void ('V').
+    #
+    # The +rtype+ argument is the return type for the function.  The valid
+    # characters are the same as for the +proto+. The default is long ('L').
+    #
+    # The 'B' (BOOL) return type is the same as 'I' (Integer). This is
+    # significant only if the API.auto_method option is set to true, in which
+    # case it alters the generated method definition slightly. See the
+    # API.auto_method= class method for more information.
+    #
+    # The +dll+ is the name of the DLL file that the function is exported
+    # from. The default is 'kernel32'.
+    #
+    # If the function cannot be found then an API::Error is raised (a subclass
+    # of RuntimeError).
+    #
+    def initialize(func, proto='V', rtype='L', dll='kernel32')
+      # Convert literal data types to values that win32-api understands
+      if proto.is_a?(Array)
+        proto.each_with_index{ |pt, index|
+          if pt.length > 1
+            proto[index].replace(DATA_TYPES[pt])
+          end
+        }
+      end
+
+      if rtype.length > 1
+        rtype.replace(DATA_TYPES[rtype])
+      end
+
+      @function_name = func
+      @prototype     = proto
+      @return_type   = rtype == 'B' ? 'I' : rtype
+      @dll_name      = dll
+      @boolean       = rtype == 'B' ? true : false
+
+      @api = Win32::API.new(func, proto, rtype, dll)
+
+      api_a = nil
+      api_w = nil
+
+      # If the auto_unicode option is set, and the func is not already
+      # an explicit ANSI or Wide function name, generate Win32::API
+      # objects for those functions as well. Ignore errors because not
+      # all functions have explicit ANSI or Wide character implementations.
+      #
+      # This entire bit of logic is skipped if the DLL is msvcrt, since
+      # msvcrt functions never have explicit ANSI or Wide character
+      # versions.
+      #
+      if Windows::API.auto_unicode && dll !~ /msvcr/i
+        begin
+          unless ['A', 'W'].include?(func[-1].chr)
+            api_a = Win32::API.new("#{func}A", proto, rtype, dll)
+          end
+        rescue RuntimeError
+        end
+
+        begin
+          unless ['W', 'A'].include?(func[-1].chr)
+            api_w = Win32::API.new("#{func}W", proto, rtype, dll)
+          end
+        rescue RuntimeError
+        end
+      end
+
+      func_upper = nil
+
+      # Automatically define a constant matching the function name if the
+      # auto_constant option is set. Lower case method names will have a
+      # capitalized equivalent created, e.g. Memcpy for memcpy, etc.
+      #
+      if Windows::API.auto_constant && Windows::API.auto_namespace
+        if Windows::API.auto_namespace != 'Windows'
+          namespace = class_for(Windows::API.auto_namespace)
+        else
+          namespace = Windows::API.auto_namespace
+        end
+
+        # Convert e.g. 'strstr' to 'Strstr' as an equivalent constant
+        if ('A'..'Z').include?(func[0].chr)
+          namespace.const_set(func, @api)
+        else
+          func_upper = func.dup
+          if func_upper[0].chr == '_'
+            func_upper = func_upper[1, func_upper.length]
+          end
+          func_upper[0, 1] = func_upper[0].chr.capitalize
+          namespace.const_set(func_upper, @api)
+        end
+
+        # Automatically define the explicit ANSI and Unicode functions
+        # as constants as well, if appropriate.
+        #
+        if Windows::API.auto_unicode
+          namespace.const_set("#{func}A", api_a) if api_a
+          namespace.const_set("#{func}W", api_w) if api_w
+        end
+      end
+
+      # Automatically define a method in the auto_namespace if the
+      # auto_method option is set. The explicit ANSI and Unicode methods
+      # are added as well if the auto_unicode option is set to true.
+      #
+      if Windows::API.auto_method && Windows::API.auto_namespace
+        if proto == 'V'
+          proto = ''
+        else
+          n = 0
+          if proto.is_a?(String)
+            proto = proto.split('').map{ |e|
+              n += 1
+              e.downcase + n.to_s
+            }.join(', ')
+          else
+            proto = proto.map{ |e|
+              n += 1
+              e.downcase + n.to_s
+            }.join(', ')
+          end
+        end
+
+        # Use the upper case function equivalent if defined
+        call_func = func_upper || func
+
+        if @boolean
+          string = <<-EOC
+            module #{Windows::API.auto_namespace}
+              def #{func}(#{proto})
+                #{call_func}.call(#{proto}) != 0
+              end
+            EOC
+
+          if api_a
+            string << %Q{
+              def #{func}A(#{proto})
+                #{call_func}A.call(#{proto}) != 0
+              end
+            }
+          end
+
+          if api_w
+            string << %Q{
+              def #{func}W(#{proto})
+                #{call_func}W.call(#{proto}) != 0
+              end
+            }
+          end
+
+          string << 'end'
+        else
+          string = <<-EOC
+            module #{Windows::API.auto_namespace}
+              def #{func}(#{proto})
+                #{call_func}.call(#{proto})
+              end
+            EOC
+
+          if api_a
+            string << %Q{
+              def #{func}A(#{proto})
+                #{call_func}A.call(#{proto})
+              end
+            }
+          end
+
+          if api_w
+            string << %Q{
+              def #{func}W(#{proto})
+                #{call_func}W.call(#{proto})
+              end
+            }
+          end
+
+          # Create aliases for methods with an underscore that do not
+          # require an underscore, e.g. umask and _umask.
+          if func[0].chr == '_'
+            func_alias = func[1, func.length]
+            string << "alias #{func_alias} #{func}\n"
+          end
+
+          string << 'end'
+        end
+
+        eval(string)
+      end
+    end
+
+    # Calls the function name set in the constructor.
+    #
+    def call(*args)
+      @api.call(*args)
+    end
+
+    private
+
+    # Get a module's namespace. This is basically the equivalent of
+    # the rb_path2class() function from intern.h
+    #
+    def class_for(class_name)
+      names = class_name.split("::")
+      result = Object
+      names.each{ |n| result = result.const_get(n) }
+      result
+    end
+  end
+end