win_gui 0.1.0 → 0.1.1

data/README.rdoc

@@ -1,22 +1,38 @@
 = win_gui
+    by: Arvicco
+    url: http://github.com/arvicco/git_hub
 
-== Description
+== DESCRIPTION:
 
 Welcome to WinGui!
 
 WinGui is a module that provides convenient wrapper methods for multiple Win32 API
-functions (mostly from user32.dll) dealing with GUI manipulation/automation.
+functions (mostly from user32.dll) dealing with Windows GUI manipulation/automation.
 In addition to straightforward API wrappers, it also defines more Ruby-like
 abstractions and convenience methods for manipulating windows and other GUI 
 elements (such as WinGui::Window class and its methods).
 
 It is still work in progress, only a small number of API functions wrapped so far...
 
-== Documentation
+== DOCUMENTATION:
 
 See WinGui and WinGui::Window for documentation
 
-== Examples
+== REQUIREMENTS:
+
+Only works with Ruby 1.9.1+ since it uses some of the most recent features (block
+arguments given to block, etc...)
+
+== FEATURES/PROBLEMS:
+
+This project is quite new, so it's probably not ready for prime time just yet...
+Contributors always welcome!
+
+== INSTALL:
+
+  $ sudo gem install win_gui
+
+== SYNOPSIS:
 
   require 'win_gui'
   include WinGui
@@ -33,11 +49,11 @@ More examples will follow as the code will be closer to production quality...
   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
-== Credits
+== CREDITS:
 
 This library started as an extension of ideas and code described in excellent book
 "Scripted GUI Testing with Ruby" by Ian Dees.
 
-== Copyright
+== LICENSE:
 
-Copyright (c) 2010 arvicco. See LICENSE for details.
+Copyright (c) 2009 Arvicco. See LICENSE for details

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/win_gui/def_api.rb

@@ -0,0 +1,55 @@
+module WinGui
+  module DefApi
+    # Defines new instance method wrapper for Windows API function call. Converts CamelCase function name
+    # into snake_case method name, renames test functions according to Ruby convention (IsWindow -> window?)
+    # When the defined wrapper method is called, it executes underlying API function call, yields the result
+    # to attached block (if any) and (optionally) transforms the result before returning it.
+    #
+    # You may modify default defined method behavior by providing optional &define_block to def_api.
+    # If you do so, instead of directly calling API function, defined method yields callable api object, arguments
+    # and (optional) runtime block to &define_block that should define method content and return result.
+    #
+    # Accepts following options:
+    # :rename:: Use this name instead of standard (conventional) function name
+    # :alias(es):: Provides additional alias(es) for defined method
+    # :boolean:: Forces method to return true/false instead of nonzero/zero
+    # :zeronil:: Forces method to return nil if function result is zero
+    #
+    def def_api(function, params, returns, options={}, &define_block)
+      name = options[:rename] || function.snake_case
+      if name.sub!(/^is_/, '')
+        name << '?'
+        boolean = true
+      end
+      boolean ||= options[:boolean]
+      zeronil = options[:zeronil]
+      aliases = ([options[:alias]] + [options[:aliases]]).flatten.compact
+      proto = params.respond_to?(:join) ? params.join : params # Converts params into prototype string
+      api = Win32::API.new(function, proto.upcase, returns.upcase, options[:dll] || WG_DLL_DEFAULT)
+
+      define_method(name) do |*args, &runtime_block| 
+        return api if args == [:api]
+        return define_block.call(api, *args, &runtime_block) if define_block
+        raise 'Invalid args count' unless args.size == params.size
+        result = api.call(*args)
+        yield result if runtime_block
+        return result != 0 if boolean       # Boolean function returns true/false instead of nonzero/zero
+        return nil if zeronil && result == 0
+        result
+      end
+      aliases.each {|aliass| alias_method aliass, name } unless aliases == []
+    end
+
+    # Helper methods:
+
+    # Converts block into API::Callback object that can be used as API callback argument
+    def callback(params, returns, &block)
+      Win32::API::Callback.new(params, returns, &block)
+    end
+
+    # Returns string buffer - used to supply string pointer reference to API functions
+    def buffer(size = 1024, code = "\x00")
+      code * size
+    end
+  end
+end

data/lib/win_gui/win_gui.rb

@@ -1,48 +1,19 @@
 require 'Win32/api'
 require 'string_extensions'
 require 'constants'
+require 'def_api'
 require 'window'
 
-#TODO - When calling API functions, win_handle arg should default to instance var @handle of the host class
-#TODO - Giving a hash of "named args" to def_api, like this:
-#TODO        def_api 'ShowWindow', 'LI' , 'I', :args=>{1=>:handle=>, 2=>[:cmd, :command]}
-#TODO - Giving a hash of "defaults" to def_api, like this:
-#TODO        def_api 'ShowWindow', 'LI' , 'I', :defaults=>{1=>1234, 2=>'String2'}
-#TODO - Option :class_method should define CLASS method instead of instance
+#  TODO - When calling API functions, win_handle arg should default to instance var @handle of the host class
+#  TODO - Giving a hash of "named args" to def_api, like this:
+#  TODO        def_api 'ShowWindow', 'LI' , 'I', :args=>{1=>:handle=>, 2=>[:cmd, :command]}
+#  TODO - Giving a hash of "defaults" to def_api, like this:
+#  TODO        def_api 'ShowWindow', 'LI' , 'I', :defaults=>{1=>1234, 2=>'String2'}
+#  TODO - Option :class_method should define CLASS method instead of instance
 
 module WinGui
-
-  # Class meta-method used to define API wrappers
-  def self.def_api(function, params, returns, options={}, &define_block)
-    name = function.snake_case
-    name.sub!(/^is_/, '') << '?' if name =~ /^is_/
-    boolean = options[:boolean] || name =~ /\?$/ # Boolean function returns true/false instead of nonzero/zero
-    proto = params.respond_to?(:join) ? params.join : params # Converts params into prototype string
-    api = Win32::API.new(function, proto.upcase, returns.upcase, options[:dll] || WG_DLL_DEFAULT)
-
-    define_method(options[:rename] || name) do |*args, &runtime_block|
-      return api if args == [:api]
-      return define_block.call(api, *args, &runtime_block) if define_block
-      raise 'Invalid args count' unless args.size == params.size
-      result = api.call(*args)
-      yield result if runtime_block
-      return result != 0 if boolean
-      return nil if options[:zeronil] && result == 0
-      result
-    end
-  end
-
-  # Converts block into API::Callback object that can be used as API callback argument
-  def self.callback(params, returns, &block)
-    Win32::API::Callback.new(params, returns, &block)
-  end
-
-  # Helper methods:
-  # returns string buffer - used to supply string pointer reference to API functions
-  def self.buffer(size = 1024, code = "\x00")
-    code * size
-  end
-
+  self.extend DefApi
+  
   return_string_proc = lambda do |api, *args|
     raise 'Invalid args count' unless args.size == api.prototype.size-2
     args += [string = buffer, string.length]
@@ -72,23 +43,23 @@ module WinGui
     handles
   end
 
-  # Windows API definitions:
-  def_api 'IsWindow', 'L', 'L'
+  # Windows GUI API definitions:
+
   # Tests whether the specified window handle identifies an existing window.
   #   A thread should not use IsWindow for a window that it did not create because the window could be destroyed after this
   #   function was called. Further, because window handles are recycled the handle could even point to a different window.
+  def_api 'IsWindow', 'L', 'L'
 
-  def_api 'IsWindowVisible', 'L', 'L'
-  alias visible? window_visible?
   # Tests if the specified window, its parent window, its parent's parent window, and so forth, have the WS_VISIBLE style.
   # Because the return value specifies whether the window has the WS_VISIBLE style, it may be true even if the window is totally obscured by other windows.
+  def_api 'IsWindowVisible', 'L', 'L'
+  alias visible? window_visible?
 
   def_api 'IsZoomed', 'L', 'L'
   alias maximized? zoomed?
   # Tests whether the specified window is maximized.
 
-  def_api 'IsIconic', 'L', 'L'
-  alias minimized? iconic?
+  def_api 'IsIconic', 'L', 'L', :alias => :minimized?
   # Tests whether the specified window is maximized.
 
   def_api 'IsChild', 'LL', 'L'

data/spec/spec_helper.rb

@@ -50,6 +50,10 @@ module GuiTest
     find_window(nil, nil)
   end
 
+  def not_a_handle
+    123
+  end
+
   def any_block
     lambda {|*args| args}
   end

data/spec/win_gui/def_api_spec.rb

@@ -0,0 +1,242 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper" )
+
+module GuiTest 
+
+#  def enum_callback
+#    @enum_callback ||= WinGui.callback('LP', 'I'){|handle, message| true }
+#  end
+
+  describe WinGui::DefApi, 'defines wrappers for Win32::API functions' do
+    before(:each) { hide_method :find_window_w } # hide original method if it is defined
+    after(:each) { restore_method :find_window_w } # restore original method if it was hidden
+
+    context 'defining a valid API function' do
+      spec{ use{ WinGui.def_api('FindWindowW', 'PP', 'L', :rename => nil, :alias => nil, :boolean => nil, :zeronil => nil, &any_block) }}
+
+      it 'defines new instance method with appropriate name' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L'
+        respond_to?(:find_window_w).should be_true
+      end
+
+      it 'constructs argument prototype from uppercase string' do
+        expect { WinGui.def_api 'FindWindowW', 'PP', 'L' }.to_not raise_error
+        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
+        expect { find_window_w(nil, nil) }.to_not raise_error 'Invalid args count'
+      end
+
+      it 'constructs argument prototype from lowercase string' do
+        expect { WinGui.def_api 'FindWindowW', 'pp', 'l' }.to_not raise_error
+        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
+        expect { find_window_w(nil, nil) }.to_not raise_error 'Invalid args count'
+      end
+
+      it 'constructs argument prototype from (mixedcase) array' do
+        expect { WinGui.def_api 'FindWindowW', ['p', 'P'], 'L' }.to_not raise_error
+        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
+        expect { find_window_w(nil, nil) }.to_not raise_error 'Invalid args count'
+      end
+
+      it 'overrides standard name for defined method with :rename option' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L', :rename=> 'my_own_find'
+        expect {find_window_w(nil, nil)}.to raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+      end
+
+      it 'adds alias for defined method with :alias option' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L', :alias => 'my_own_find'
+        expect {find_window_w(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+      end
+
+      it 'adds aliases for defined method with :aliases option' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1']
+        expect {find_window_w(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+        expect {my_own_find1(nil, nil)}.to_not raise_error
+      end
+
+      it 'defined method works properly when called with a valid args' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L'
+        expect {find_window_w(nil, nil)}.to_not raise_error
+      end
+
+      it 'defined method returns expected value when called' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L'
+        find_window_w(nil, nil).should_not == 0
+        find_window_w(nil, TEST_IMPOSSIBLE).should == 0
+        find_window_w(TEST_IMPOSSIBLE, nil).should == 0
+        find_window_w(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
+      end
+
+      it 'defined method enforces the argument count when called' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L'
+        expect { find_window_w }.to raise_error 'Invalid args count'
+        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
+        expect { find_window_w('Str') }.to raise_error 'Invalid args count'
+        expect { find_window_w([nil, nil]) }.to raise_error 'Invalid args count'
+        expect { find_window_w('Str', 'Str', 'Str') }.to raise_error 'Invalid args count'
+      end
+
+      it 'returns underlying Win32::API object if defined method is called with (:api) argument ' do
+        WinGui.def_api 'FindWindowW', 'PP', 'L'
+        expect {@api = find_window_w(:api)}.to_not raise_error
+        @api.dll_name.should == 'user32' # The name of the DLL that exports the API function
+        @api.effective_function_name.should == 'FindWindowW' # Actual function returned by the constructor: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
+        @api.function_name.should == 'FindWindowW' # The name of the function passed to the constructor
+        @api.prototype.should == ['P', 'P'] # The prototype, returned as an array of characters
+      end
+    end
+
+    context 'auto-defining Ruby-like boolean methods if API function name starts with "Is_"' do
+      before(:each) do
+        hide_method :window?
+        WinGui.def_api 'IsWindow', 'L', 'L'
+      end
+      after(:each) { restore_method :window? }
+
+      it 'defines new instance method name dropping Is_ and adding ?' do
+        respond_to?(:window?).should be_true
+      end
+
+      it 'defined method returns false/true instead of zero/non-zero' do
+        window?(any_handle).should == true
+        window?(not_a_handle).should == false
+      end
+
+      it 'defined method enforces the argument count' do
+        expect {window?}.to raise_error 'Invalid args count'
+        expect {window?(not_a_handle, nil)}.to raise_error 'Invalid args count'
+        expect {window?(nil, nil)}.to raise_error 'Invalid args count'
+      end
+    end
+
+    context 'defining API with :boolean option converts result to boolean' do
+      before(:each) do
+        WinGui.def_api 'FindWindowW', 'PP', 'L', :boolean => true
+      end
+
+      it 'defines new instance method' do
+        respond_to?(:find_window_w).should be_true
+      end
+
+      it 'defined method returns false/true instead of zero/non-zero' do
+        find_window_w(nil, nil).should == true
+        find_window_w(nil, TEST_IMPOSSIBLE).should == false
+      end
+
+      it 'defined method enforces the argument count' do
+        expect {find_window_w}.to raise_error 'Invalid args count'
+        expect {find_window_w(nil, nil, nil)}.to raise_error 'Invalid args count'
+      end
+    end
+
+    context 'defining API with :zeronil option converts zero result to nil' do
+      before(:each) do
+        WinGui.def_api 'FindWindowW', 'PP', 'L', :zeronil => true
+      end
+
+      it 'defines new instance method' do
+        respond_to?(:find_window_w).should be_true
+      end
+
+      it 'defined method returns nil (but NOT false) instead of zero' do
+        find_window_w(nil, TEST_IMPOSSIBLE).should_not == false
+        find_window_w(nil, TEST_IMPOSSIBLE).should == nil
+      end
+
+      it 'defined method does not return true when result is non-zero' do
+        find_window_w(nil, nil).should_not == true
+        find_window_w(nil, nil).should_not == 0
+      end
+
+      it 'defined method enforces the argument count' do
+        expect {find_window_w}.to raise_error 'Invalid args count'
+        expect {find_window_w(nil, nil, nil)}.to raise_error 'Invalid args count'
+      end
+    end
+
+    context 'trying to define an invalid API function' do
+      it 'raises error when trying to define function with a wrong function name' do
+        expect { WinGui.def_api 'FindWindowImpossible', 'PP', 'L' }.
+                to raise_error( /Unable to load function 'FindWindowImpossible'/ )
+      end
+    end
+
+    context 'defining API function using definition blocks' do
+
+      it 'defines new instance method' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L' ){|api, *args|}
+        respond_to?(:find_window_w).should be_true
+      end
+
+      it 'does not enforce argument count outside of block' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L' ){|api, *args|}
+        expect { find_window_w }.to_not raise_error 'Invalid args count'
+        expect { find_window_w(nil) }.to_not raise_error 'Invalid args count'
+        expect { find_window_w(nil, 'Str') }.to_not raise_error 'Invalid args count'
+      end
+
+      it 'returns block return value when defined method is called' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L' ){|api, *args| 'Value'}
+        find_window_w(nil).should == 'Value'
+      end
+
+      it 'passes arguments and underlying Win32::API object to the block' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L' ) do |api, *args|
+          @api = api
+          @args = args
+        end
+        find_window_w(1, 2, 3)
+        @args.should == [1, 2, 3]
+        @api.function_name.should == 'FindWindowW' # The name of the function passed to the constructor
+      end
+
+      it ':rename option overrides standard name for defined method' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L', :rename => 'my_own_find' ){|api, *args|}
+        expect {find_window_w(nil, nil, nil)}.to raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+      end
+      it 'adds alias for defined method with :alias option' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L', :alias => 'my_own_find' ){|api, *args|}
+        expect {find_window_w(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+      end
+
+      it 'adds aliases for defined method with :aliases option' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1'] ) {|api, *args|}
+        expect {find_window_w(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
+        expect {my_own_find1(nil, nil)}.to_not raise_error
+      end
+
+      it 'returns underlying Win32::API object if defined method is called with (:api) argument ' do
+        WinGui.def_api( 'FindWindowW', 'PP', 'L' ){|api, *args|}
+        expect {@api = find_window_w(:api)}.to_not raise_error
+        @api.dll_name.should == 'user32' # The name of the DLL that exports the API function
+        @api.effective_function_name.should == 'FindWindowW' # Actual function returned by the constructor: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
+        @api.function_name.should == 'FindWindowW' # The name of the function passed to the constructor
+        @api.prototype.should == ['P', 'P'] # The prototype, returned as an array of characters
+      end
+    end
+
+    context 'providing API function with callback' do
+      before(:each) { hide_method :enum_windows } # hide original find_window method if it is defined
+      after(:each) { restore_method :enum_windows } # restore original find_window method if it was hidden
+
+      it '#callback method creates a valid callback object' do
+        expect { @callback = WinGui.callback('LP', 'I') {|handle, message| true} }.to_not raise_error
+        @callback.should be_a_kind_of(Win32::API::Callback)
+      end
+
+      it 'created callback object can be used as a valid arg of API function expecting callback' do
+        WinGui.def_api 'EnumWindows', 'KP', 'L'
+        @enum_callback ||= WinGui.callback('LP', 'I'){|handle, message| true }
+        expect { enum_windows(@enum_callback, 'Message') }.to_not raise_error
+      end
+
+      it 'defined API functions expecting callback recognize/accept blocks' do
+        pending ' API is not exactly clear atm (what about prototype?)(.with_callback method?)'
+      end
+    end
+  end
+end

data/spec/win_gui/win_gui_spec.rb

@@ -1,256 +1,6 @@
 require File.join(File.dirname(__FILE__), "..", "spec_helper" )
 
 module GuiTest
-
-#  def enum_callback
-#    @enum_callback ||= callback('LP', 'I'){|handle, message| true }
-#  end
-
-  describe WinGui, ' defines wrappers for Win32::API functions' do
-
-    context 'defining a valid API function' do
-      before(:each) { hide_method :find_window_w } # hide original method if it is defined
-      after(:each) { restore_method :find_window_w } # restore original method if it was hidden
-
-      spec{ use{ WinGui.def_api('FindWindowW', 'PP', 'L', :rename => nil, :boolean => nil, :zeronil => nil, &any_block) }}
-
-      it 'defines new instance method with appropriate name' do
-        WinGui.def_api 'FindWindowW', 'PP', 'L'
-        respond_to?(:find_window_w).should be_true
-      end
-
-      it 'constructs argument prototype from uppercase string' do
-        expect { WinGui.def_api 'FindWindowW', 'PP', 'L' }.to_not raise_error
-        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
-        expect { find_window_w(nil, nil) }.to_not raise_error 'Invalid args count'
-      end
-
-      it 'constructs argument prototype from lowercase string' do
-        expect { WinGui.def_api 'FindWindowW', 'pp', 'l' }.to_not raise_error
-        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
-        expect { find_window_w(nil, nil) }.to_not raise_error 'Invalid args count'
-      end
-
-      it 'constructs argument prototype from (mixedcase) array' do
-        expect { WinGui.def_api 'FindWindowW', ['p', 'P'], 'L' }.to_not raise_error
-        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
-        expect { find_window_w(nil, nil) }.to_not raise_error 'Invalid args count'
-      end
-
-      it ':rename option overrides standard name for defined method' do
-        WinGui.def_api 'FindWindowW', 'PP', 'L', :rename=> 'my_own_find'
-        expect {find_window_w(nil, nil)}.to raise_error
-        expect {my_own_find(nil, nil)}.to_not raise_error
-      end
-
-      it 'defined method works properly when called with a valid args' do
-        WinGui.def_api 'FindWindowW', 'PP', 'L'
-        expect {find_window_w(nil, nil)}.to_not raise_error
-      end
-
-      it 'defined method returns expected value when called' do
-        WinGui.def_api 'FindWindowW', 'PP', 'L'
-        test_app do |app|
-          find_window_w(nil, TEST_WIN_TITLE.to_w).should_not == 0
-          find_window_w(TEST_WIN_CLASS.to_w, nil).should_not == 0
-        end
-        find_window_w(nil, nil).should_not == 0
-        find_window_w(nil, TEST_IMPOSSIBLE).should == 0
-        find_window_w(TEST_IMPOSSIBLE, nil).should == 0
-        find_window_w(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
-      end
-
-      it 'defined method enforces the argument count when called' do
-        WinGui.def_api 'FindWindowW', 'PP', 'L'
-        expect { find_window_w }.to raise_error 'Invalid args count'
-        expect { find_window_w(nil) }.to raise_error 'Invalid args count'
-        expect { find_window_w('Str') }.to raise_error 'Invalid args count'
-        expect { find_window_w([nil, nil]) }.to raise_error 'Invalid args count'
-        expect { find_window_w('Str', 'Str', 'Str') }.to raise_error 'Invalid args count'
-      end
-
-      it 'defined method called with (:api) argument returns underlying Win32::API object' do
-        WinGui.def_api 'FindWindowW', 'PP', 'L'
-        expect {@api = find_window_w(:api)}.to_not raise_error
-        @api.dll_name.should == 'user32' # The name of the DLL that exports the API function
-        @api.effective_function_name.should == 'FindWindowW' # Actual function returned by the constructor: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
-        @api.function_name.should == 'FindWindowW' # The name of the function passed to the constructor
-        @api.prototype.should == ['P', 'P'] # The prototype, returned as an array of characters
-      end
-    end
-
-    context 'auto-defining Ruby-like boolean methods if API function name starts with "Is_"' do
-      before(:each) do
-        hide_method :window?
-        WinGui.def_api 'IsWindow', 'L', 'L'
-      end
-      after(:each) { restore_method :window? }
-
-      it 'defines new instance method name dropping Is_ and adding ?' do
-        respond_to?(:window?).should be_true
-      end
-
-      it 'defined method returns true instead of non-zero' do
-        window?(any_handle).should == true
-      end
-
-      it 'defined method returns false instead of zero' do
-        window?(123).should == false
-      end
-
-      it 'defined method enforces the argument count' do
-        expect {window?}.to raise_error 'Invalid args count'
-        expect {window?(123, nil)}.to raise_error 'Invalid args count'
-        expect {window?(nil, nil)}.to raise_error 'Invalid args count'
-      end
-    end
-
-    context 'defining API with :boolean option converts result to boolean' do
-      before(:each) do
-        hide_method :show_window
-        WinGui.def_api 'ShowWindow', 'LI', 'I', :boolean => true
-      end
-      after(:each) { restore_method :show_window }
-
-      it 'defines new instance method' do
-        respond_to?(:show_window).should be_true
-      end
-
-      it 'defined method returns true instead of non-zero' do
-        test_app {|app| show_window(app.handle, SW_SHOWNA).should == true }
-      end
-
-      it 'defined method returns false instead of zero' do
-        test_app do |app|
-          show_window(app.handle, SW_HIDE)
-          show_window(app.handle, SW_HIDE).should == false
-        end
-      end
-
-      it 'defined method enforces the argument count' do
-        test_app do |app|
-          expect {show_window}.to raise_error 'Invalid args count'
-          expect {show_window(app.handle, SW_HIDE, nil)}.to raise_error 'Invalid args count'
-        end
-      end
-    end
-
-    context 'defining API with :zeronil option converts zero result to nil' do
-      before(:each) do
-        hide_method :show_window
-        WinGui.def_api 'ShowWindow', 'LI', 'I', :zeronil => true
-      end
-      after(:each) { restore_method :show_window }
-
-      it 'defines new instance method' do
-        respond_to?(:show_window).should be_true
-      end
-
-      it 'defined method returns nil (but NOT false) instead of zero' do
-        test_app do |app|
-          show_window(app.handle, SW_HIDE)
-          show_window(app.handle, SW_HIDE).should == nil
-          show_window(app.handle, SW_HIDE).should_not == false
-        end
-      end
-
-      it 'defined method does not return true when result is non-zero' do
-        test_app do |app|
-          result = show_window(app.handle, SW_SHOWNA)
-          result.should_not == 0
-          result.should_not == true
-        end
-      end
-
-      it 'defined method enforces the argument count' do
-        test_app do |app|
-          expect {show_window}.to raise_error 'Invalid args count'
-          expect {show_window(app.handle, SW_HIDE, nil)}.to raise_error 'Invalid args count'
-        end
-      end
-    end
-
-    context 'trying to define an invalid API function' do
-      it 'raises error when trying to define function with a wrong function name' do
-        expect { WinGui.def_api 'FindWindowImpossible', 'PP', 'L' }.
-                to raise_error( /Unable to load function 'FindWindowImpossible'/ )
-      end
-    end
-
-    context 'defining API function using definition blocks' do
-      before(:each) { hide_method :get_window_text } # hide original method if it is defined
-      after(:each) { restore_method :get_window_text } # restore original method if it was hidden
-
-      it 'defines new instance method' do
-        WinGui.def_api 'GetWindowText', 'LPL', 'L' do |api, *args|
-        end
-        respond_to?(:get_window_text).should be_true
-      end
-
-      it 'does not enforce argument count outside of block' do
-        WinGui.def_api 'GetWindowText', 'LPL', 'L' do |api, *args|
-        end
-        expect { get_window_text }.to_not raise_error 'Invalid args count'
-        expect { get_window_text(nil) }.to_not raise_error 'Invalid args count'
-        expect { get_window_text(nil, 'Str') }.to_not raise_error 'Invalid args count'
-      end
-
-      it 'returns block return value when defined method is called' do
-        WinGui.def_api 'GetWindowText', 'LPL', 'L' do |api, *args|
-          'Value'
-        end
-        get_window_text(nil).should == 'Value'
-      end
-
-      it 'passes arguments and underlying Win32::API object to the block' do
-        WinGui.def_api 'GetWindowText', 'LPL', 'L' do |api, *args|
-          @api=api; @args = args
-        end
-        get_window_text(1, 2, 3)
-        @args.should == [1, 2, 3]
-        @api.function_name.should == 'GetWindowText' # The name of the function passed to the constructor
-      end
-
-      it ':rename option overrides standard name for defined method' do
-        WinGui.def_api 'GetWindowText', 'LPL', 'L', :rename => 'my_name' do |api, *args|
-        end
-        expect {get_window_text(nil, nil, nil)}.to raise_error
-        expect {my_name(nil, nil)}.to_not raise_error
-      end
-
-      it 'calling defined method with (:api) argument returns underlying Win32::API object' do
-        WinGui.def_api 'GetWindowText', 'LPL', 'L' do |api, *args|
-        end
-        expect {@api = get_window_text(:api)}.to_not raise_error
-        @api.dll_name.should == 'user32' # The name of the DLL that exports the API function
-        @api.effective_function_name.should == 'GetWindowTextA' # Actual function returned by the constructor: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
-        @api.function_name.should == 'GetWindowText' # The name of the function passed to the constructor
-        @api.prototype.should == ['L', 'P', 'L'] # The prototype, returned as an array of characters
-      end
-    end
-
-    context 'providing API function with callback' do
-      #    before(:each) { hide_method :enum_windows } # hide original find_window method if it is defined
-      #    after(:each) { restore_method :enum_window } # restore original find_window method if it was hidden
-      #    
-      it '#callback method creates a valid callback object' do
-        pending 'callback is now a class method of WinGui, not available here (exept through module_eval)'
-        expect { @callback = callback('LP', 'I') {|handle, message| true} }.to_not raise_error
-        @callback.should be_a_kind_of(Win32::API::Callback)
-      end
-
-      it 'created callback object can be used as a valid arg of API function expecting callback' do
-        pending 'API changed - callback arg is no longer valid, block is used instead'
-        #      WinGui.def_api 'EnumWindows', 'KP', 'L'
-        expect { enum_windows(enum_callback, 'Message') }.to_not raise_error
-      end
-
-      it 'defined API functions expecting callback recognize/accept blocks' do
-        pending ' API is not exactly clear atm (what about prototype?)(.with_callback method?)'
-      end
-    end
-  end
-
   describe WinGui, ' contains a set of pre-defined GUI functions' do
     describe '#window?' do
       spec{ use{ window?(handle = 0) }}

data/win_gui.gemspec

@@ -0,0 +1,215 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{win_gui}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["arvicco"]
+  s.date = %q{2010-01-26}
+  s.description = %q{Rubyesque interfaces and wrappers for Win32 API GUI functions}
+  s.email = %q{arvitallian@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "book_code/early_success/bundle.rb",
+     "book_code/early_success/english.txt",
+     "book_code/early_success/jruby_basics.rb",
+     "book_code/early_success/windows_basics.rb",
+     "book_code/guessing/locknote.rb",
+     "book_code/guessing/monkeyshines.rb",
+     "book_code/guessing/note.rb",
+     "book_code/guessing/note_spec.rb",
+     "book_code/guessing/replay.rb",
+     "book_code/guessing/seed.rb",
+     "book_code/guessing/spec_helper.rb",
+     "book_code/guessing/windows_gui.rb",
+     "book_code/home_stretch/junquenote.rb",
+     "book_code/home_stretch/locknote.rb",
+     "book_code/home_stretch/note.rb",
+     "book_code/home_stretch/note_spec.rb",
+     "book_code/home_stretch/spec_helper.rb",
+     "book_code/home_stretch/swing_gui.rb",
+     "book_code/home_stretch/windows_gui.rb",
+     "book_code/junquenote/exports.sh",
+     "book_code/junquenote/jruby_mac.sh",
+     "book_code/junquenote/junquenote_app.rb",
+     "book_code/novite/Rakefile",
+     "book_code/novite/app/controllers/application.rb",
+     "book_code/novite/app/controllers/guests_controller.rb",
+     "book_code/novite/app/controllers/parties_controller.rb",
+     "book_code/novite/app/helpers/application_helper.rb",
+     "book_code/novite/app/helpers/guests_helper.rb",
+     "book_code/novite/app/helpers/parties_helper.rb",
+     "book_code/novite/app/models/guest.rb",
+     "book_code/novite/app/models/party.rb",
+     "book_code/novite/app/models/party_mailer.rb",
+     "book_code/novite/app/views/layouts/application.rhtml",
+     "book_code/novite/app/views/parties/new.html.erb",
+     "book_code/novite/app/views/parties/show.html.erb",
+     "book_code/novite/app/views/party_mailer/invite.erb",
+     "book_code/novite/config/boot.rb",
+     "book_code/novite/config/database.yml",
+     "book_code/novite/config/environment.rb",
+     "book_code/novite/config/environments/development.rb",
+     "book_code/novite/config/environments/production.rb",
+     "book_code/novite/config/environments/test.rb",
+     "book_code/novite/config/initializers/inflections.rb",
+     "book_code/novite/config/initializers/mime_types.rb",
+     "book_code/novite/config/routes.rb",
+     "book_code/novite/db/migrate/001_create_parties.rb",
+     "book_code/novite/db/migrate/002_create_guests.rb",
+     "book_code/novite/db/schema.rb",
+     "book_code/novite/log/empty.txt",
+     "book_code/novite/public/.htaccess",
+     "book_code/novite/public/404.html",
+     "book_code/novite/public/422.html",
+     "book_code/novite/public/500.html",
+     "book_code/novite/public/dispatch.cgi",
+     "book_code/novite/public/dispatch.fcgi",
+     "book_code/novite/public/dispatch.rb",
+     "book_code/novite/public/favicon.ico",
+     "book_code/novite/public/images/rails.png",
+     "book_code/novite/public/index.html",
+     "book_code/novite/public/javascripts/application.js",
+     "book_code/novite/public/javascripts/controls.js",
+     "book_code/novite/public/javascripts/dragdrop.js",
+     "book_code/novite/public/javascripts/effects.js",
+     "book_code/novite/public/javascripts/prototype.js",
+     "book_code/novite/public/robots.txt",
+     "book_code/novite/script/about",
+     "book_code/novite/script/console",
+     "book_code/novite/script/destroy",
+     "book_code/novite/script/generate",
+     "book_code/novite/script/performance/benchmarker",
+     "book_code/novite/script/performance/profiler",
+     "book_code/novite/script/performance/request",
+     "book_code/novite/script/plugin",
+     "book_code/novite/script/process/inspector",
+     "book_code/novite/script/process/reaper",
+     "book_code/novite/script/process/spawner",
+     "book_code/novite/script/runner",
+     "book_code/novite/script/server",
+     "book_code/novite/test/test_helper.rb",
+     "book_code/one_more_thing/applescript.rb",
+     "book_code/one_more_thing/note_spec.rb",
+     "book_code/one_more_thing/spec_helper.rb",
+     "book_code/one_more_thing/textedit-pure.rb",
+     "book_code/one_more_thing/textedit.applescript",
+     "book_code/one_more_thing/textedit.rb",
+     "book_code/one_more_thing/textnote.rb",
+     "book_code/simplify/junquenote.rb",
+     "book_code/simplify/locknote.rb",
+     "book_code/simplify/note.rb",
+     "book_code/simplify/note_spec.rb",
+     "book_code/simplify/swing_gui.rb",
+     "book_code/simplify/windows_gui.rb",
+     "book_code/simplify/windows_gui_spec.rb",
+     "book_code/story/invite.story",
+     "book_code/story/journal.txt",
+     "book_code/story/novite_stories.rb",
+     "book_code/story/party.rb",
+     "book_code/story/password.rb",
+     "book_code/story/password.story",
+     "book_code/story/rsvp.story",
+     "book_code/tables/TestTime.html",
+     "book_code/tables/TestTimeSample.html",
+     "book_code/tables/calculate_time.rb",
+     "book_code/tables/calculator.rb",
+     "book_code/tables/calculator_actions.rb",
+     "book_code/tables/calculator_spec.rb",
+     "book_code/tables/fit.rb",
+     "book_code/tables/matrix.rb",
+     "book_code/tables/pseudocode.rb",
+     "book_code/tubes/book_selenium.rb",
+     "book_code/tubes/book_watir.rb",
+     "book_code/tubes/dragdrop.html",
+     "book_code/tubes/html_capture.rb",
+     "book_code/tubes/joke_list.rb",
+     "book_code/tubes/list_spec.rb",
+     "book_code/tubes/search_spec.rb",
+     "book_code/tubes/selenium_example.rb",
+     "book_code/tubes/selenium_link.rb",
+     "book_code/tubes/web_server.rb",
+     "book_code/windows/wgui.rb",
+     "book_code/windows/wobj.rb",
+     "book_code/windows/wsh.rb",
+     "book_code/with_rspec/empty_spec.rb",
+     "book_code/with_rspec/junquenote.rb",
+     "book_code/with_rspec/locknote.rb",
+     "book_code/with_rspec/note_spec.rb",
+     "book_code/with_rspec/should_examples.rb",
+     "features/step_definitions/win_gui_steps.rb",
+     "features/support/env.rb",
+     "features/win_gui.feature",
+     "lib/note.rb",
+     "lib/note/java/jemmy.jar",
+     "lib/note/java/jnote.rb",
+     "lib/note/java/jruby_basics.rb",
+     "lib/note/java/junquenote_app.rb",
+     "lib/note/java/note_spec.rb",
+     "lib/note/win/locknote.rb",
+     "lib/win_gui.rb",
+     "lib/win_gui/constants.rb",
+     "lib/win_gui/def_api.rb",
+     "lib/win_gui/string_extensions.rb",
+     "lib/win_gui/win_gui.rb",
+     "lib/win_gui/window.rb",
+     "old/windows_basics.rb",
+     "old/wnote.rb",
+     "old/wnote_spec.rb",
+     "spec/note/win/locknote_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/test_apps/locknote/LockNote.exe",
+     "spec/win_gui/def_api_spec.rb",
+     "spec/win_gui/string_extensions_spec.rb",
+     "spec/win_gui/win_gui_spec.rb",
+     "spec/win_gui/window_spec.rb",
+     "win_gui.gemspec"
+  ]
+  s.homepage = %q{http://github.com/arvicco/win_gui}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Rubyesque interfaces and wrappers for Win32 API GUI functions}
+  s.test_files = [
+    "spec/note/win/locknote_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/win_gui/def_api_spec.rb",
+     "spec/win_gui/string_extensions_spec.rb",
+     "spec/win_gui/window_spec.rb",
+     "spec/win_gui/win_gui_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<win32-api>, [">= 1.4.5"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<cucumber>, [">= 0"])
+    else
+      s.add_dependency(%q<win32-api>, [">= 1.4.5"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<cucumber>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<win32-api>, [">= 1.4.5"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<cucumber>, [">= 0"])
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win_gui
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - arvicco
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-20 00:00:00 +03:00
+date: 2010-01-26 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -185,14 +185,6 @@ files:
 - book_code/with_rspec/locknote.rb
 - book_code/with_rspec/note_spec.rb
 - book_code/with_rspec/should_examples.rb
-- exp/exp.rb
-- exp/exp_encodings.rb
-- exp/exp_enum_windows.rb
-- exp/exp_quik.rb
-- exp/exp_wsh.rb
-- exp/old/windows_basics.rb
-- exp/old/wnote.rb
-- exp/old/wnote_spec.rb
 - features/step_definitions/win_gui_steps.rb
 - features/support/env.rb
 - features/win_gui.feature
@@ -205,16 +197,22 @@ files:
 - lib/note/win/locknote.rb
 - lib/win_gui.rb
 - lib/win_gui/constants.rb
+- lib/win_gui/def_api.rb
 - lib/win_gui/string_extensions.rb
 - lib/win_gui/win_gui.rb
 - lib/win_gui/window.rb
+- old/windows_basics.rb
+- old/wnote.rb
+- old/wnote_spec.rb
 - spec/note/win/locknote_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/test_apps/locknote/LockNote.exe
+- spec/win_gui/def_api_spec.rb
 - spec/win_gui/string_extensions_spec.rb
 - spec/win_gui/win_gui_spec.rb
 - spec/win_gui/window_spec.rb
+- win_gui.gemspec
 has_rdoc: true
 homepage: http://github.com/arvicco/win_gui
 licenses: []
@@ -246,6 +244,7 @@ summary: Rubyesque interfaces and wrappers for Win32 API GUI functions
 test_files: 
 - spec/note/win/locknote_spec.rb
 - spec/spec_helper.rb
+- spec/win_gui/def_api_spec.rb
 - spec/win_gui/string_extensions_spec.rb
 - spec/win_gui/window_spec.rb
 - spec/win_gui/win_gui_spec.rb

data/exp/exp.rb

@@ -1,6 +0,0 @@
-
-p File.dirname(__FILE__),__FILE__, __LINE__
-p __LINE__, File.open(__FILE__).lines.to_a[__LINE__-1]
-
-
-

data/exp/exp_encodings.rb

@@ -1,40 +0,0 @@
-# encoding: CP1251
-Encoding.default_internal, Encoding.default_external = ['utf-8'] * 2
-t = '��������� �����������!'
-d = t.encode('CP866')
-utf8 = t.encode('utf-8')
-
-puts '��������� �����������!', t, utf8, "#{d}  #{d.encoding}"
-
-str = "\xE2\x80\x93"
-puts "Str: #{str}, #{str.encoding}"
-
-p "Source encoding: #{__ENCODING__}"
-p "String encoding: #{t.encoding}"
-p "Def ext encoding: #{Encoding.default_external}"
-p "Def int encoding: #{Encoding.default_internal}"
-
-puts
-
-puts 'Playing with encodings: setting default to utf-8'
-Encoding.default_internal, Encoding.default_external = ['utf-8'] * 2
-p "Source encoding: #{__ENCODING__}"
-p "Def ext encoding: #{Encoding.default_external}"
-p "Def int encoding: #{Encoding.default_internal}"
-zhopa ='Yes, ��� ����!!'
-puts zhopa
-p "String encoding: #{zhopa.encoding}"
-puts zhopa.encode!('CP866', :undef => :replace)
-p "String encoding: #{zhopa.encoding}"
-
-puts
-puts 'Playing with encodings: setting default to cp866'
-Encoding.default_internal, Encoding.default_external = ['cp866'] * 2
-p "Source encoding: #{__ENCODING__}"
-p "Def ext encoding: #{Encoding.default_external}"
-p "Def int encoding: #{Encoding.default_internal}"
-zhopa ='Yes, ��� ����!!'
-puts zhopa
-p "String encoding: #{zhopa.encoding}"
-puts zhopa.encode!('CP866', :undef => :replace)
-p "String encoding: #{zhopa.encoding}"

data/exp/exp_enum_windows.rb

@@ -1,60 +0,0 @@
-#encoding: utf-8
-
-
-# When using API functions returning ANSI strings (get_window_text), force_encoding('cp1251') and encode('cp866', :undef => :replace) to display correctly
-# When using API functions returning "wide" Unicode strings (get_window_text_w), force_encoding('utf-16LE') and encode('cp866', :undef => :replace) to display correctly
-
-libdir = File.join(File.dirname(__FILE__),"lib" )
-$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
-require 'spec/spec_helper'
-
-include WinGui
-include GuiTest
-
-@child_handles = []
-app = launch_test_app
-#keystroke(VK_ALT, 'F'.ord)
-print_callback = lambda do |handle, message|
-  name = get_window_text(handle)
-  class_name = get_class_name(handle)
-  thread, process = get_window_thread_process_id(handle) 
-  puts "#{message}  #{process}  #{thread}  #{handle}  #{class_name.rstrip} #{name.force_encoding('cp1251').encode('cp866', :undef => :replace).rstrip}"
-  @child_handles << handle if message == 'CHILD'
-  true
-end
-
-@windows = []
-@num = 0
-map_callback = lambda do |handle, message|
-  name = get_window_text_w(handle)
-  class_name = get_class_name(handle)
-  thread, process = get_window_thread_process_id(handle) 
-  @windows << { :message => message, :process => process, :thread => thread, :handle => handle, :klass => class_name.rstrip,  
-    :name => name.encode('cp866', :undef => :replace).rstrip}
-  @num +=1
-  true
-end
-
-#print_callback = callback('LP', 'I', &print_proc)
-#map_callback = callback('LP', 'I', &map_proc)
-
-puts "Top-level Windows:"
-enum_windows 'TOP', &print_callback
-
-puts
-puts "Note Windows:"
-print_callback[app.handle, 'NOTE']
-enum_child_windows app.handle, 'CHILD', &print_callback
-
-@child_handles.each do |handle|
-  enum_child_windows handle, 'CHILD', &print_callback
-end
-
-enum_windows 'TOP', &map_callback
-enum_child_windows app.handle, 'CHILD', &map_callback
-puts
-puts "Sorted Windows:"
-puts @windows.sort_by{|w| [w[:process], w[:thread], w[:handle]]}.map{|w|w.values.join('  ')}
-puts "Total #{@num} Windows"
-
-close_test_app

data/exp/exp_quik.rb

@@ -1,38 +0,0 @@
-# encoding: UTF-8
-libdir = File.join(File.dirname(__FILE__), "lib" )
-$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
-require 'spec/spec_helper'
-
-module Quik
-  include WinGui
-  extend WinGui
-  include GuiTest
-
-  QUIK_APP_PATH = ['C:\Program Files\Info', '\info.exe']
-  QUIK_APP_START = 'start "" "' + QUIK_APP_PATH.join + '"'
-  QUIK_MAIN_CLASS = 'InfoClass'
-  QUIK_DIALOG_CLASS = '#32770'
-  QUIK_DIALOG_TITLE = 'Идентификация пользователя'
-  system 'cd "' + QUIK_APP_PATH.first + '"'
-  system QUIK_APP_START
-  handle = 0
-  timeout(20) do
-    sleep TEST_SLEEP_DELAY until (handle = find_window(QUIK_MAIN_CLASS, nil))
-  end
-  p handle
-  quik = Window.new handle
-  sleep 1
-  p visible? quik.handle
-#  hide_window(quik.handle)
-  p window? quik.handle
-  p visible? quik.handle
-  p QUIK_DIALOG_TITLE#.force_encoding('CP1251')
-  p title = QUIK_DIALOG_TITLE.encode('CP1251')
-  dialog( title, 1) do |dlg|
-    child = dlg.child 'ComboLBox'
-    p 'Found!', child.handle
-  end
-#  quik.close
-#  quik.wait_for_close
-
-end

data/exp/exp_wsh.rb

@@ -1,115 +0,0 @@
-# encoding: UTF-8
-require 'win32ole'
-
-p WIN32OLE.codepage
-
-def show ole, name = 'ole_obj'
-  puts " #{name} is: #{ole.ole_type.inspect}" if ole.respond_to? :ole_type
-  puts " #{name}'s Additonal methods:"
-  p (ole.methods - Object.methods).map(&:to_s).uniq.sort
-  if ole.respond_to? :ole_methods
-    puts " #{name}'s OLE methods:"
-    #p ole.ole_methods.map(&:to_s).uniq.sort
-    methods = ole.ole_methods.select{ |m| m.visible? }.sort{|a, b| a.to_s<=>b.to_s}
-    puts methods.map {|meth| signature_for meth }
-  end
-  puts
-end
-
-def signature_for meth
-  sig = "#{meth.return_type} "
-  sig += "#{meth.return_type_detail} " unless meth.return_type_detail.size == 1
-  sig += "#{meth.name}("
-  sig +=  meth.params.map {|param| param_for param}.join(", ") unless meth.params.empty?
-  sig += ")"
-end
-
-def param_for param
-  if param.default
-    "#{param.ole_type} #{param.name}=#{param.default}"
-  else
-    "#{param.ole_type} #{param.name}"
-  end
-end
-
-# Object WScript.Shell
-show wsh = WIN32OLE.new('Wscript.Shell'), 'Wscript.Shell'
-
-#wsh.Popup( 'message', 0, 'title', 1 ) # Pop-up, Doh
-#puts wsh.CurrentDirectory()
-show env = wsh.Environment, "wsh.Environment"
-env.each {|env_item| puts "   -  #{env_item}"}
-puts
-
-# Echo?
-#e = WIN32OLE.new('WScript.Echo "Hello World!"')
-
-show shell = WIN32OLE.new('Shell.Application'), 'Shell.Application'
-# Must be either IE or Windows Explorer
-show windows = shell.Windows, 'shell.Windows'
-
-puts "# of windows: #{windows.count.inspect}"
-show windows.ole_method('GetTypeInfo'), "ole_method('GetTypeInfo')"
-
-show expl = windows.Item(0), "windows.Item(0)"
-
-# Playing with CD-ROM
-show my_computer = shell.NameSpace(17), 'shell.NameSpace(17) - my computer'
-
-show cdrom = my_computer.ParseName("D:\\"), 'ParseName("D:\\") - cdrom'
-
-cdrom.Verbs.each do |verb|
-  show verb, verb.Name
-  #verb.doIt if verb.Name == "E&ject"
-end
-
-## Documenting Win32OLE
-#my_com_object = WIN32OLE.new("Library.Class")
-#
-## Set my_com_object = GetObject("Library.Class")
-#com_collection_object = WIN32OLE.connect("Library.Class")
-#
-## For Each com_object In com_collection_object
-## '...
-## Next
-#for com_object in com_collection_object
-#  p com_object.ole_methods
-##...
-#end
-
-exit 0
-
-# Playing with Folder
-time = Time.now.to_s
-if wsh.AppActivate('Фолдор')
-  wsh.SendKeys("%FWFRB#{time}{ENTER}")
-end
-
-# Creating new Notepad window:
-if not wsh.AppActivate('Notepad')
-  wsh.Run('Notepad')
-  sleep 1
-end
-
-# Playing with created Notepad window:
-if wsh.AppActivate('Notepad')
-  sleep 1
-  p 'Inside'
-  # Enter text into Notepad:
-  wsh.SendKeys('Ruby{TAB}on{TAB}Windows{ENTER}')
-  wsh.SendKeys("#{time}")
-  # ALT-F to pull down File menu, then A to select Save As...:
-  wsh.SendKeys('%FA')
-  sleep 1
-  wsh.SendKeys('C:\dev\apps\filename.txt{ENTER}')
-  sleep 1
-  # If prompted to overwrite existing file:
-
-  if wsh.AppActivate('Save As')
-    sleep 1
-    # Enter 'Y':
-    wsh.SendKeys('Y')
-  end
-  # Quit Notepad with ALT-F4:
-  wsh.SendKeys('%{F4}')
-end