win_gui 0.1.2 → 0.1.3

data/spec/win_gui/def_api_spec.rb

@@ -2,177 +2,213 @@ require File.join(File.dirname(__FILE__), "..", "spec_helper" )
 
 module GuiTest
 
-#  def enum_callback
-#    @enum_callback ||= WinGui.callback('LP', 'I'){|handle, message| true }
-#  end
+  def should_be symbol, api
+    case symbol
+      when :find_window
+        api.dll_name.should == 'user32' # The name of the DLL that exports the API function
+        api.effective_function_name.should == 'FindWindowA' # Actual function returned by the constructor: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
+        api.function_name.should == 'FindWindow' # The name of the function passed to the constructor
+        api.prototype.should == ['P', 'P'] # The prototype, returned as an array of characters
+    end
+  end
+
+  def redefined_methods
+    [:find_window, :is_window, :window?, :enum_windows, :get_computer_name, :computer_name]
+  end
+
+  def should_count_args(*methods, rights, wrongs)
+    rights = [rights].flatten
+    wrongs = [wrongs].flatten
+    methods.each do |method|
+      (1..8).each do |n|
+        if n == rights.size
+          expect {send method, *rights}.to_not raise_error
+        else
+        args = (1..n).map {wrongs[rand(wrongs.size)]}
+        expect {send method, *args}.
+                to raise_error "wrong number of parameters: expected #{rights.size}, got #{args.size}"
+        end
+      end
+    end
+  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
+    before(:each) { hide_method *redefined_methods } # hide original methods if  defined
+    after(:each) { restore_method *redefined_methods } # restore original methods if 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) }}
+    context 'defining enhanced API function method' do
+      spec{ use{ WinGui.def_api('FindWindow', 'PP', 'L', rename: nil, aliases: 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
+      it 'defines new instance methods with appropriate names' do
+        WinGui.def_api 'FindWindow', 'PP', 'L'
+        respond_to?(:find_window).should be_true
+        respond_to?(:FindWindow).should be_true
+      end
+
+      it 'constructs argument prototype from uppercase string, enforces the args count' do
+        expect { WinGui.def_api 'FindWindow', 'PP', 'L' }.to_not raise_error
+        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
       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'
+      it 'constructs argument prototype from lowercase string, enforces the args count' do
+        expect { WinGui.def_api 'FindWindow', 'pp', 'l' }.to_not raise_error
+        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
       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'
+      it 'constructs argument prototype from (mixedcase) array, enforces the args count' do
+        expect { WinGui.def_api 'FindWindow', ['p', 'P'], 'L' }.to_not raise_error
+        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
       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'
+      it 'with :rename option, overrides snake_case name for defined method but leaves CamelCase intact' do
+        WinGui.def_api 'FindWindow', 'PP', 'L', :rename=> 'my_own_find'
+        expect {find_window(nil, nil)}.to raise_error NoMethodError
+        expect {FindWindow(nil, nil)}.to_not raise_error
+        expect {my_own_find(nil, nil)}.to_not raise_error
       end
 
-      it 'overrides standard dll name with :dll option' do
+      it 'defined snake_case method returns expected value when called' do
+        WinGui.def_api 'FindWindow', 'PP', 'L'
+        find_window(nil, nil).should_not == 0
+        find_window(nil, TEST_IMPOSSIBLE).should == 0
+        find_window(TEST_IMPOSSIBLE, nil).should == 0
+        find_window(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
+      end
 
-        WinGui.def_api 'GetComputerName', ['P', 'P'], 'I', :dll=> 'kernel32'
-        sys_name = `echo %COMPUTERNAME%`.strip
-        name = " " * 128
-        get_computer_name(name, "128")
-        name.unpack("A*").first.should == sys_name
+      it 'defined CamelCase method returns expected value when called' do
+        WinGui.def_api 'FindWindow', 'PP', 'L'
+        FindWindow(nil, nil).should_not == 0
+        FindWindow(nil, TEST_IMPOSSIBLE).should == 0
+        FindWindow(TEST_IMPOSSIBLE, nil).should == 0
+        FindWindow(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
       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
+      it 'returns underlying Win32::API object if defined method is called with (:api) argument ' do
+        WinGui.def_api 'FindWindow', 'PP', 'L'
+        expect {find_window(:api)}.to_not raise_error
+        should_be :find_window, find_window(:api)
       end
+    end
 
+    context 'defining aliases' do
       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
+        WinGui.def_api 'FindWindow', 'PP', 'L', :alias => 'my_own_find'
+        expect {find_window(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
+        WinGui.def_api 'FindWindow', 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1']
+        expect {find_window(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
+      it 'adds Rubyesque alias to IsXxx API test function' do
+        WinGui.def_api 'IsWindow', 'L', 'L'
+        respond_to?(:window?).should be_true
+        respond_to?(:is_window).should be_true
       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'
+      it 'adds Rubyesque alias to GetXxx API getter function' do
+        WinGui.def_api 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'
+        respond_to?(:get_computer_name).should be_true
+        respond_to?(:computer_name).should be_true
       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? }
+      before(:each) {WinGui.def_api 'IsWindow', 'L', 'L'}
 
       it 'defines new instance method name dropping Is_ and adding ?' do
         respond_to?(:window?).should be_true
+        respond_to?(:is_window).should be_true
+        respond_to?(:IsWindow).should be_true
       end
 
-      it 'defined method returns false/true instead of zero/non-zero' do
+      it 'defined CamelCase method returns zero/non-zero as expected' do
+        IsWindow(any_handle).should_not == true
+        IsWindow(any_handle).should_not == 0
+        IsWindow(not_a_handle).should == 0
+      end
+
+      it 'defined snake_case method returns false/true instead of zero/non-zero' do
         window?(any_handle).should == true
         window?(not_a_handle).should == false
+        is_window(any_handle).should == true
+        is_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'
+      it 'defined methods enforce the argument count' do
+        should_count_args :window?, :is_window, :IsWindow,  [not_a_handle], [nil, not_a_handle, any_handle]
       end
     end
 
     context 'defining API with :boolean option converts result to boolean' do
       before(:each) do
-        WinGui.def_api 'FindWindowW', 'PP', 'L', :boolean => true
+        WinGui.def_api 'FindWindow', 'PP', 'L', :boolean => true
       end
 
       it 'defines new instance method' do
-        respond_to?(:find_window_w).should be_true
+        respond_to?(:find_window).should be_true
+        respond_to?(:FindWindow).should be_true
+      end
+
+      it 'defined snake_case method returns false/true instead of zero/non-zero' do
+        find_window(nil, nil).should == true
+        find_window(nil, TEST_IMPOSSIBLE).should == false
       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
+      it 'defined CamelCase method still returns zero/non-zero' do
+        FindWindow(nil, nil).should_not == true
+        FindWindow(nil, nil).should_not == 0
+        FindWindow(nil, TEST_IMPOSSIBLE).should == 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'
+      it 'defined methods enforce the argument count' do
+        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
       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
+        WinGui.def_api 'FindWindow', 'PP', 'L', :zeronil => true
       end
 
       it 'defines new instance method' do
-        respond_to?(:find_window_w).should be_true
+        respond_to?(:find_window).should be_true
+        respond_to?(:FindWindow).should be_true
+      end
+
+      it 'defined CamelCase method still returns zero/non-zero' do
+        FindWindow(nil, nil).should_not == true
+        FindWindow(nil, nil).should_not == 0
+        FindWindow(nil, TEST_IMPOSSIBLE).should == 0
       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
+        find_window(nil, TEST_IMPOSSIBLE).should_not == false
+        find_window(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
+        find_window(nil, nil).should_not == true
+        find_window(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'
+      it 'defined methods enforce the argument count' do
+        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
       end
     end
 
     context 'using DLL other than default user32 with :dll option' do
-      before(:each) do
-        hide_method :get_computer_name # hide original method if it is defined
-        WinGui.def_api 'GetComputerName', ['P', 'P'], 'I', :dll=> 'kernel32'
-      end
-      after(:each) { restore_method :get_computer_name } # restore original method if it was hidden
+      before(:each) {WinGui.def_api 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'}
 
       it 'defines new instance method with appropriate name' do
+        respond_to?(:GetComputerName).should be_true
         respond_to?(:get_computer_name).should be_true
+        respond_to?(:computer_name).should be_true
       end
 
       it 'returns expected result' do
@@ -192,66 +228,81 @@ module GuiTest
     end
 
     context 'defining API function using definition block' do
-
       it 'defines new instance method' do
-        WinGui.def_api( 'FindWindowW', 'PP', 'L' ){|api, *args|}
-        respond_to?(:find_window_w).should be_true
+        WinGui.def_api( 'FindWindow', 'PP', 'L' ){|api, *args|}
+        respond_to?(:find_window).should be_true
+        respond_to?(:FindWindow).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'
+        WinGui.def_api( 'FindWindow', 'PP', 'L' ){|api, *args|}
+        expect { find_window }.to_not raise_error
+        expect { find_window(nil) }.to_not raise_error
+        expect { find_window(nil, 'Str', 1) }.to_not raise_error
       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'
+        WinGui.def_api( 'FindWindow', 'PP', 'L' ){|api, *args| 'Value'}
+        find_window(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|
+        WinGui.def_api( 'FindWindow', 'PP', 'L' ) do |api, *args|
           @api = api
           @args = args
         end
-        find_window_w(1, 2, 3)
+        expect {find_window(1, 2, 3) }.to_not raise_error
         @args.should == [1, 2, 3]
-        @api.function_name.should == 'FindWindowW' # The name of the api function passed to the block
+        should_be :find_window, @api
       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
+        WinGui.def_api( 'FindWindow', 'PP', 'L', :rename => 'my_own_find' ){|api, *args|}
+        expect {find_window(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
+        WinGui.def_api( 'FindWindow', 'PP', 'L', :alias => 'my_own_find' ){|api, *args|}
+        expect {find_window(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
+        WinGui.def_api( 'FindWindow', 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1'] ) {|api, *args|}
+        expect {find_window(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
+        WinGui.def_api( 'FindWindow', 'PP', 'L' ){|api, *args|}
+        expect {find_window(:api)}.to_not raise_error
+        should_be :find_window, find_window(:api)
       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
+    context 'calling defined methods with attached block to preprocess the API function results' do
+      it 'defined method yields raw result to block attached to its invocation' do
+        WinGui.def_api 'FindWindow', 'PP', 'L', zeronil: true
+        find_window(nil, TEST_IMPOSSIBLE) {|result| result.should == 0 }
+      end
+
+      it 'defined method returns result of block attached to its invocation' do
+        WinGui.def_api 'FindWindow', 'PP', 'L', zeronil: true
+        return_value = find_window(nil, TEST_IMPOSSIBLE) {|result| 'Value'}
+        return_value.should == 'Value'
+      end
+
+      it 'defined method transforms result of block before returning it' do
+        WinGui.def_api 'FindWindow', 'PP', 'L', zeronil: true
+        return_value = find_window(nil, TEST_IMPOSSIBLE) {|result| 0 }
+        return_value.should_not == 0
+        return_value.should == nil
+      end
+    end
 
+    context 'working with API function callbacks' do
       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)

data/spec/win_gui/win_gui_spec.rb

@@ -22,7 +22,7 @@ module GuiTest
       end
     end
 
-    describe '#window_visible?' do
+    describe '#window_visible?' do 
       spec{ use{ window_visible?(handle = any_handle) }}
       spec{ use{ visible?(handle = any_handle) }}
 
@@ -199,6 +199,10 @@ module GuiTest
       spec{ use{ text = get_window_text(handle = 0)}}
       # Improved with block to accept window handle as a single arg and return (rstripped) text string 
 
+      it 'returns nil if incorrect window handle given' do
+        get_window_text(0).should == nil
+      end
+
       it 'returns correct window text' do
         test_app {|app| get_window_text(app.handle).should == TEST_WIN_TITLE }
       end
@@ -208,6 +212,10 @@ module GuiTest
       spec{ use{ class_name = get_window_text_w(handle = 0)}} # result encoded as utf-8
       # Unicode version of get_window_text (strings returned encoded as utf-8)
 
+      it 'returns nil if incorrect window handle given' do
+        get_window_text(0).should == nil
+      end
+
       it 'returns correct window text' do
         test_app {|app| get_window_text_w(app.handle).should == TEST_WIN_TITLE }
       end

data/win_gui.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{win_gui}
-  s.version = "0.1.2"
+  s.version = "0.1.3"
 
   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.date = %q{2010-01-29}
   s.description = %q{Rubyesque interfaces and wrappers for Win32 API GUI functions}
   s.email = %q{arvitallian@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win_gui
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - arvicco
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-26 00:00:00 +03:00
+date: 2010-01-29 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency