windows-pr 1.2.5 → 1.2.6

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

@@ -1,27 +0,0 @@
-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

@@ -1,68 +0,0 @@
-== 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

@@ -1,9 +0,0 @@
-* 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

@@ -1,96 +0,0 @@
-== 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

@@ -1,47 +0,0 @@
-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

@@ -1,503 +0,0 @@
-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