rautomation 0.0.4 → 0.1.0

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/History.rdoc

@@ -1,3 +1,12 @@
+=== Version 0.1.0 / 2010-12-14
+
+* added new default adapter for Windows: FFI
+* changes for AutoIt adapter:
+  - added 0-based :index locator for window locators to search for windows with the same criteria.
+  - renamed text_field and button locator :instance to :index instead.
+  - :class_name locator is not allowed anymore. Use :class and :index together instead.
+  - use :value for button locator instead of :text
+
 === Version 0.0.4 / 2010-10-27
 
  * most Window, Button and TextField methods wait until the object exists.

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Jarmo Pertman
+Copyright (c) 2009-2010 Jarmo Pertman
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -12,7 +12,7 @@ RAutomation aims to provide:
 * Easy to use and user-friendly API (inspired by Watir http://www.watir.com).
 * Cross-platform compatibility
 * Easy extensibility - have some application, which uses some specialized technology, but isn't supported by RAutomation?
-  You can get dirty and create new implementation for RAutomation, due to the applied <em>Strategy Pattern</em>!
+  You can get dirty and create a new adapter for RAutomation right away!
 
 == USAGE
 
@@ -24,11 +24,14 @@ RAutomation aims to provide:
     window.title # => "blah blah part Of the title blah"
     window.text # => "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec ultricies..."
 
-    window.text_field(:class_name => "Edit1").set "hello, world!"
+    window.text_field(:class => "Edit", :index => 0).set "hello, world!"
     button = window.button(:text => "&Save")
     button.exists? # => true
     button.click
 
+    window2 = RAutomation::Window.new(:title => "Other Title", :adapter => :autoit) # use AutoIt adapter
+    window2.WinClose("[TITLE:Other Title]") # use adapter's (in this case AutoIt's) internal methods directly
+
 See more examples in spec directory!
 
 == INSTALL
@@ -38,6 +41,11 @@ See more examples in spec directory!
 1. gem install rautomation
 2. create some script and run it
 
+Available adapters:
+* :ffi - uses Windows API directly with FFI (default)
+* :autoit - uses AutoIt for automation
+
+When using AutoIt adapter:
 You might need administrative privileges if running for the first time and you haven't installed AutoIt before!
 
 === Linux

data/Rakefile

@@ -13,26 +13,21 @@ RAutomation aims to provide:
 * Easy to use and user-friendly API (inspired by Watir http://www.watir.com).
 * Cross-platform compatibility
 * Easy extensibility - have some application, which uses some specialized technology, but isn't supported by RAutomation?
-  You can get dirty and create new implementation for RAutomation, due to the applied Strategy Pattern!}
+  You can get dirty and create a new adapter for RAutomation!}
     gem.email = "jarmo.p@gmail.com"
     gem.homepage = "http://github.com/jarmo/RAutomation"
     gem.authors = ["Jarmo Pertman"]
-    gem.add_development_dependency "rspec", ">= 1.3.0"
+    gem.add_development_dependency "rspec", "~>2.3"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
+RSpec::Core::RakeTask.new(:rcov) do |spec|
   spec.rcov = true
 end
 

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.0

data/lib/rautomation.rb

@@ -1,5 +1,5 @@
 require "rautomation/wait_helper"
-require "rautomation/implementations/helper"
+require "rautomation/adapter/helper"
 require "rautomation/window"
 require "rautomation/button"
 require "rautomation/text_field"

data/lib/rautomation/{implementations → adapter}/autoit/button.rb

@@ -1,17 +1,18 @@
 module RAutomation
-  module Implementations
-    module AutoIt
+  module Adapter
+    module Autoit
       class Button
         include WaitHelper
         include Locators
 
         # Special-cased locators
         LOCATORS = {
-                :class_name => :classnn,
+                [:class, Regexp] => :regexpclass,
+                :index => :instance,
                 :value => :text
         }
 
-        # Possible locators are :text, :value, :id, :class, :class_name and :instance.
+        # Possible locators are :value, :id, :class and :index.
         def initialize(window, locators)
           @window = window
           extract(locators)

data/lib/rautomation/{implementations → adapter}/autoit/locators.rb

@@ -1,6 +1,6 @@
 module RAutomation
-  module Implementations
-    module AutoIt
+  module Adapter
+    module Autoit
       module Locators
 
         private
@@ -8,6 +8,7 @@ module RAutomation
         def extract(locators) #:nodoc:
           @locators = "[#{locators.map do |locator, value|
             locator_key = self.class::LOCATORS[locator] || self.class::LOCATORS[[locator, value.class]]
+            value = value.to_i + 1 if locator == :index # use 0-based indexing
             value = value.to_s(16) if locator == :hwnd
             "#{(locator_key || locator)}:#{value}"
           end.join(";")}]"

data/lib/rautomation/{implementations → adapter}/autoit/text_field.rb

@@ -1,14 +1,17 @@
 module RAutomation
-  module Implementations
-    module AutoIt
+  module Adapter
+    module Autoit
       class TextField
         include WaitHelper
         include Locators
 
         # Special-cased locators
-        LOCATORS = {:class_name => :classnn}
+        LOCATORS = {
+                [:class, Regexp] => :regexpclass,
+                :index => :instance
+        }
 
-        # Possible locators are :id, :class, :class_name and :instance.
+        # Possible locators are :id, :class and :index.
         def initialize(window, locators)
           @window = window
           extract(locators)

data/lib/rautomation/{implementations → adapter}/autoit/window.rb

@@ -1,6 +1,6 @@
 module RAutomation
-  module Implementations
-    module AutoIt
+  module Adapter
+    module Autoit
       class Window
         include WaitHelper
         include Locators
@@ -25,11 +25,13 @@ module RAutomation
         attr_reader :locators
 
         # Special-cased locators
-        LOCATORS = {[:title, String] => :title,
-                    [:title, Regexp] => :regexptitle,
-                    :hwnd => :handle}
+        LOCATORS = {
+                [:title, Regexp] => :regexptitle,
+                :index => :instance,
+                :hwnd => :handle
+        }
 
-        # Possible locators are :title, :text, :hwnd and :class.
+        # Possible locators are :title, :text, :hwnd, :class and :index.
         def initialize(locators)
           @hwnd = locators[:hwnd]
           @locator_text = locators.delete(:text)
@@ -80,11 +82,11 @@ module RAutomation
           sleep 1
         end
 
-        def minimized?
+        def minimized? #:nodoc:
           @@autoit.WinGetState(locator_hwnd) & 16 == 16
         end
 
-        def restore
+        def restore #:nodoc:
           @@autoit.WinSetState(locator_hwnd, "", @@autoit.SW_RESTORE)
           sleep 1
         end
@@ -94,7 +96,6 @@ module RAutomation
         # Refer to AutoIt documentation for keys syntax.
         def send_keys(keys)
           wait_until do
-            restore if minimized?
             activate
             active?
           end
@@ -115,7 +116,7 @@ module RAutomation
         end
 
         def method_missing(name, *args) #:nodoc:
-          @@autoit.respond_to?(name) ? @@autoit.send(name, *args) : super
+          @@autoit.send(name, *args)
         end
 
         # Used internally.

data/lib/rautomation/adapter/ffi.rb

@@ -0,0 +1,12 @@
+begin
+  gem "ffi", "0.6.3"
+rescue Gem::LoadError
+  raise Gem::LoadError, "Unable to load FFI gem. Install it with:\n\tgem install ffi -v 0.6.3"
+end
+require "ffi"
+require File.dirname(__FILE__) + "/ffi/constants"
+require File.dirname(__FILE__) + "/ffi/functions"
+require File.dirname(__FILE__) + "/ffi/locators"
+require File.dirname(__FILE__) + "/ffi/window"
+require File.dirname(__FILE__) + "/ffi/button"
+require File.dirname(__FILE__) + "/ffi/text_field"

data/lib/rautomation/adapter/ffi/button.rb

@@ -0,0 +1,38 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      class Button
+        include WaitHelper
+        include Locators
+
+        # Possible locators are :value, :id, :class and :index.
+        def initialize(window, locators)
+          @window = window
+          extract(locators)
+        end
+
+        def click #:nodoc:
+          clicked = false
+          wait_until do
+            hwnd = Functions.control_hwnd(@window.hwnd, @locators)
+            @window.activate
+            @window.active? &&
+                    Functions.set_control_focus(hwnd) &&
+                    Functions.control_click(hwnd) &&
+                    clicked = true # is clicked at least once
+            clicked && !exists?
+          end
+        end
+
+        def value #:nodoc:
+          Functions.control_value(Functions.control_hwnd(@window.hwnd, @locators))
+        end
+
+        def exists? #:nodoc:
+          !!Functions.control_hwnd(@window.hwnd, @locators)
+        end
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/ffi/constants.rb

@@ -0,0 +1,32 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      module Constants
+        WM_GETTEXT = 0xD
+        WM_SETTEXT = 0xC
+        WM_GETTEXTLENGTH = 0xE
+        WM_CLOSE = 0x10
+
+        SW_MAXIMIZE = 3
+        SW_MINIMIZE = 6
+        SW_RESTORE = 9
+
+        SMTO_ABORTIFHUNG = 0x2
+
+        STANDARD_RIGHTS_REQUIRED = 0xF0000 
+        SYNCHRONIZE = 0x100000
+        PROCESS_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF
+
+        BM_CLICK = 0xF5
+
+        # keybd_event constants
+        # http://msdn.microsoft.com/en-us/library/ms646304(VS.85).aspx
+        #
+        # keycodes themselves are at:
+        # http://msdn.microsoft.com/en-us/library/dd375731(v=VS.85).aspx
+        KEYEVENTF_EXTENDEDKEY = 0x1
+        KEYEVENTF_KEYUP = 0x2
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/ffi/functions.rb

@@ -0,0 +1,222 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      module Functions
+        extend FFI::Library
+
+        ffi_lib 'user32', 'kernel32'
+        ffi_convention :stdcall
+
+        callback :enum_callback, [:long, :pointer], :bool
+
+        # user32
+        attach_function :enum_windows, :EnumWindows,
+                        [:enum_callback, :pointer], :long
+        attach_function :enum_child_windows, :EnumChildWindows,
+                        [:long, :enum_callback, :pointer], :long
+        attach_function :_close_window, :CloseWindow,
+                        [:long], :bool
+        attach_function :minimized, :IsIconic,
+                        [:long], :bool
+        attach_function :_window_title, :GetWindowTextA,
+                        [:long, :pointer, :int], :int
+        attach_function :window_title_length, :GetWindowTextLengthA,
+                        [:long], :int
+        attach_function :window_exists, :IsWindow,
+                        [:long], :bool
+        attach_function :_window_class, :GetClassNameA,
+                        [:long, :pointer, :int], :int
+        attach_function :window_visible, :IsWindowVisible,
+                        [:long], :bool
+        attach_function :show_window, :ShowWindow,
+                        [:long, :int], :bool
+        attach_function :send_message, :SendMessageA,
+                        [:long, :uint, :uint, :pointer], :long
+        attach_function :send_message_timeout, :SendMessageTimeoutA,
+                        [:long, :uint, :uint, :pointer, :uint, :uint, :pointer], :bool
+        attach_function :post_message, :PostMessageA,
+                        [:long, :uint, :uint, :pointer], :bool
+        attach_function :window_thread_process_id, :GetWindowThreadProcessId,
+                        [:long, :pointer], :long
+        attach_function :attach_thread_input, :AttachThreadInput,
+                        [:long, :long, :bool], :bool
+        attach_function :set_foreground_window, :SetForegroundWindow,
+                        [:long], :bool
+        attach_function :bring_window_to_top, :BringWindowToTop,
+                        [:long], :bool
+        attach_function :set_active_window, :SetActiveWindow,
+                        [:long], :long
+        attach_function :foreground_window, :GetForegroundWindow,
+                        [], :long
+        attach_function :send_key, :keybd_event,
+                        [:uchar, :uchar, :int, :pointer], :void
+        attach_function :control_id, :GetDlgCtrlID,
+                        [:long], :int
+        attach_function :_set_control_focus, :SetFocus,
+                        [:long], :long
+
+        # kernel32
+        attach_function :open_process, :OpenProcess,
+                        [:int, :bool, :int], :long
+        attach_function :terminate_process, :TerminateProcess,
+                        [:long, :uint], :bool
+        attach_function :close_handle, :CloseHandle,
+                        [:long], :bool
+
+        class << self
+          def window_title(hwnd)
+            title_length = window_title_length(hwnd) + 1
+            title = FFI::MemoryPointer.new :char, title_length
+            _window_title(hwnd, title, title_length)
+            title.read_string
+          end
+
+          def window_text(hwnd)
+            found_text = ""
+            window_callback = FFI::Function.new(:bool, [:long, :pointer], {:convention => :stdcall}) do |child_hwnd, _|
+              found_text << text_for(child_hwnd)
+              true
+            end
+            enum_child_windows(hwnd, window_callback, nil)
+            found_text
+          end
+
+          def window_hwnd(locators)
+            find_hwnd(locators) do |hwnd|
+              window_visible(hwnd) && !window_text(hwnd).empty? &&
+                      locators_match?(locators, window_properties(hwnd, locators))
+            end
+          end
+
+          def window_class(hwnd)
+            class_name = FFI::MemoryPointer.new :char, 512
+            _window_class(hwnd, class_name, 512)
+            class_name.read_string
+          end
+
+          alias_method :control_class, :window_class
+
+          def close_window(hwnd)
+            _close_window(hwnd)
+            closed = send_message_timeout(hwnd, Constants::WM_CLOSE,
+                                          0, nil, Constants::SMTO_ABORTIFHUNG, 1000, nil)
+            # force it to close
+            unless closed
+              pid = FFI::MemoryPointer.new :int
+              window_thread_process_id(hwnd, pid)
+              process_hwnd = open_process(Constants::PROCESS_ALL_ACCESS, false, pid.read_int)
+              terminate_process(process_hwnd, 0)
+              close_handle(process_hwnd)
+            end
+          end
+
+          def activate_window(hwnd)
+            set_foreground_window(hwnd)
+            set_active_window(hwnd)
+            bring_window_to_top(hwnd)
+            within_foreground_thread(hwnd) do
+              set_foreground_window(hwnd)
+              set_active_window(hwnd)
+              bring_window_to_top(hwnd)
+            end
+          end
+
+          def control_hwnd(window_hwnd, locators)
+            find_hwnd(locators, window_hwnd) do |hwnd|
+              locators_match?(locators, control_properties(hwnd, locators))
+            end
+          end
+
+          def control_value(control_hwnd)
+            text_for(control_hwnd)
+          end
+
+          def control_click(control_hwnd)
+            post_message(control_hwnd, Constants::BM_CLICK, 0, nil)
+          end
+
+          def set_control_focus(control_hwnd)
+            within_foreground_thread control_hwnd do
+              _set_control_focus(control_hwnd)
+            end
+          end
+
+          def set_control_text(control_hwnd, text)
+            send_message(control_hwnd, Constants::WM_SETTEXT, 0, text)
+          end
+
+          private
+
+          def within_foreground_thread(hwnd)
+            foreground_thread = window_thread_process_id(foreground_window, nil)
+            other_thread = window_thread_process_id(hwnd, nil)
+            attach_thread_input(foreground_thread, other_thread, true) unless other_thread == foreground_thread
+            yield
+          ensure
+            attach_thread_input(foreground_thread, other_thread, false) unless other_thread == foreground_thread
+          end
+
+          def window_properties(hwnd, locators)
+            element_properties(:window, hwnd, locators)
+          end
+
+          def control_properties(hwnd, locators)
+            element_properties(:control, hwnd, locators)
+          end
+
+          def element_properties(type, hwnd, locators)
+            locators.inject({}) do |properties, locator|
+              properties[locator[0]] = self.send("#{type}_#{locator[0]}", hwnd) unless locator[0] == :index
+              properties
+            end
+          end
+
+          def locators_match?(locators, properties)
+            locators.all? do |locator, value|
+              if locator == :index
+                true
+              elsif value.is_a?(Regexp)
+                properties[locator] =~ value
+              else
+                properties[locator] == value
+              end
+            end
+          end
+
+          def find_hwnd(locators, window_hwnd = nil)
+            found_hwnd = nil
+            found_index = -1
+            window_callback = FFI::Function.new(:bool, [:long, :pointer], {:convention => :stdcall}) do |hwnd, _|
+              if yield(hwnd)
+                found_index += 1
+
+                if locators[:index]
+                  found_hwnd = hwnd if locators[:index] == found_index
+                else
+                  found_hwnd = hwnd
+                end
+              end
+              !found_hwnd
+            end
+
+            unless window_hwnd
+              enum_windows(window_callback, nil)
+            else
+              enum_child_windows(window_hwnd, window_callback, nil)
+            end
+
+            found_hwnd
+          end
+
+          def text_for(hwnd)
+            text_length = send_message(hwnd, Constants::WM_GETTEXTLENGTH, 0, nil) + 1
+            text = FFI::MemoryPointer.new :char, text_length
+            send_message(hwnd, Constants::WM_GETTEXT, text_length, text)
+            text.read_string
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/ffi/locators.rb

@@ -0,0 +1,16 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      module Locators
+
+        private
+
+        def extract(locators) #:nodoc:
+          locators[:id] = locators[:id].to_i if locators[:id]
+          locators[:index] = locators[:index].to_i if locators[:index]
+          @locators = locators
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/ffi/text_field.rb

@@ -0,0 +1,40 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      class TextField
+        include WaitHelper
+        include Locators
+
+        # Possible locators are :id, :class and :index.
+        def initialize(window, locators)
+          @window = window
+          extract(locators)
+        end
+
+        def set(text) #:nodoc:
+          wait_until do
+            hwnd = Functions.control_hwnd(@window.hwnd, @locators)
+            @window.activate
+            @window.active? &&
+                    Functions.set_control_focus(hwnd) &&
+                    Functions.set_control_text(hwnd, text) &&
+                    value == text
+          end
+        end
+
+        def clear #:nodoc:
+          set ""
+        end
+
+        def value #:nodoc:
+          Functions.control_value(Functions.control_hwnd(@window.hwnd, @locators))
+        end
+
+        def exists? #:nodoc:
+          !!Functions.control_hwnd(@window.hwnd, @locators)
+        end
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/ffi/window.rb

@@ -0,0 +1,102 @@
+module RAutomation
+  module Adapter
+    module Ffi
+      class Window
+        include WaitHelper
+        include Locators
+
+        attr_reader :locators
+
+        # Possible locators are :title, :text, :hwnd and :class.
+        def initialize(locators)
+          @hwnd = locators.delete(:hwnd)
+          extract(locators)
+        end
+
+        # Returns handle of the found window.
+        # Searches only for visible windows with having some text at all.
+        def hwnd #:nodoc:
+          @hwnd ||= Functions.window_hwnd(@locators)
+        end
+
+        def title #:nodoc:
+          Functions.window_title(hwnd)
+        end
+
+        def activate #:nodoc:
+          return if !exists? || active?
+          restore if minimized?
+          Functions.activate_window(hwnd)
+          sleep 1
+        end
+
+        def active? #:nodoc:
+          exists? && Functions.foreground_window == hwnd
+        end
+
+        def text #:nodoc:
+          Functions.window_text(hwnd)
+        end
+
+        def exists? #:nodoc:
+          result = hwnd && Functions.window_exists(hwnd)
+          !!result
+        end
+
+        def visible? #:nodoc:
+          Functions.window_visible(hwnd)
+        end
+
+        def maximize #:nodoc:
+          Functions.show_window(hwnd, Constants::SW_MAXIMIZE)
+          sleep 1
+        end
+
+        def minimize #:nodoc:
+          Functions.show_window(hwnd, Constants::SW_MINIMIZE)
+          sleep 1
+        end
+
+        def minimized? #:nodoc:
+          Functions.minimized(hwnd)
+        end
+
+        def restore #:nodoc:
+          Functions.show_window(hwnd, Constants::SW_RESTORE)
+          sleep 1
+        end
+
+        # Activates the Window and sends keys to it.
+        #
+        # Refer to MSDN documentation at http://msdn.microsoft.com/en-us/library/dd375731(v=VS.85).aspx
+        # for keycodes.
+        def send_keys(*keys)
+          keys.each do |key|
+            wait_until do
+              activate
+              active?
+            end
+            Functions.send_key(key, 0, 0, nil)
+            Functions.send_key(key, 0, Constants::KEYEVENTF_KEYUP, nil)
+          end
+        end
+
+        def close #:nodoc:
+          Functions.close_window(hwnd)
+        end
+
+        def button(locator) #:nodoc:
+          Button.new(self, locator)
+        end
+
+        def text_field(locator) #:nodoc:
+          TextField.new(self, locator)
+        end
+
+        def method_missing(name, *args) #:nodoc:
+          Functions.respond_to?(name) ? Functions.send(name, *args) : super
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/{implementations → adapter}/helper.rb

@@ -1,15 +1,16 @@
 module RAutomation
-  module Implementations
-    autoload :AutoIt, File.dirname(__FILE__) + "/autoit.rb"
+  module Adapter
+    autoload :Autoit, File.dirname(__FILE__) + "/autoit.rb"
+    autoload :Ffi, File.dirname(__FILE__) + "/ffi.rb"
 
     module Helper
       extend self
 
       # @private
-      def default_implementation
+      def default_adapter
         case RUBY_PLATFORM
           when /mswin|msys|mingw32/
-            Implementations::AutoIt::Window
+            :ffi
           else
             raise "unsupported platform for RAutomation: #{RUBY_PLATFORM}"
         end

data/lib/rautomation/button.rb

@@ -35,7 +35,7 @@ module RAutomation
     def wait_until_exists
       WaitHelper.wait_until(RAutomation::Window.wait_timeout) {exists?}
     rescue WaitHelper::TimeoutError
-      raise UnknownButtonException.new("Button #{@locators.inspect} doesn't exist on window #{@window.locators.inspect}!")
+      raise UnknownButtonException, "Button #{@locators.inspect} doesn't exist on window #{@window.locators.inspect}!"
     end
   end
 end

data/lib/rautomation/text_field.rb

@@ -43,7 +43,7 @@ module RAutomation
     def wait_until_exists
       WaitHelper.wait_until(RAutomation::Window.wait_timeout) {exists?}
     rescue WaitHelper::TimeoutError
-      raise UnknownTextFieldException.new("Text field #{@locators.inspect} doesn't exist on window #{@window.locators.inspect}!") unless exists?
+      raise UnknownTextFieldException, "Text field #{@locators.inspect} doesn't exist on window #{@window.locators.inspect}!" unless exists?
     end
   end
 end

data/lib/rautomation/window.rb

@@ -7,13 +7,13 @@ module RAutomation
   end
 
   class Window
-    include Implementations::Helper
+    include Adapter::Helper
 
-    attr_reader :implementation
+    attr_reader :adapter
 
     # Creates a new Window object using the _locators_ Hash parameter.
     #
-    # Possible Window _locators_ may depend of the used platform and implementation, but
+    # Possible Window _locators_ may depend of the used platform and adapter, but
     # following examples will use :title, :class and :hwnd.
     #
     # Use window with _some title_ being part of it's title:
@@ -28,19 +28,19 @@ module RAutomation
     # It is possible to use multiple locators together where every locator will be matched (AND-ed) to the window:
     #   RAutomation::Window.new(:title => "some title", :class => "IEFrame")
     #
-    # Refer to all possible locators in each implementation's documentation.
+    # Refer to all possible locators in each adapter's documentation.
     #
-    # _locators_ may also include a key called :implementation to change default implementation,
+    # _locators_ may also include a key called :adapter to change default adapter,
     # which is dependent of the platform, to automate windows and their controls.
     #
-    # It is also possible to change default implementation by using environment variable:
-    # <em>RAUTOMATION_IMPLEMENTATION</em>
+    # It is also possible to change default adapter by using environment variable:
+    # <em>RAUTOMATION_ADAPTER</em>
     #
     # * Object creation doesn't check for window's existence.
     # * Window to be searched for has to be visible!
     def initialize(locators)
-      @implementation = locators.delete(:implementation) || ENV["RAUTOMATION_IMPLEMENTATION"] || default_implementation
-      @window = @implementation.new(locators)
+      @adapter = locators.delete(:adapter) || ENV["RAUTOMATION_ADAPTER"] && ENV["RAUTOMATION_ADAPTER"].to_sym || default_adapter
+      @window = Adapter.const_get(normalize(@adapter)).const_get(:Window).new(locators)
     end
 
     class << self
@@ -143,12 +143,12 @@ module RAutomation
       @window.restore
     end
 
-    # Sends keys to the Window. Refer to specific implementation's documentation for possible values.
+    # Sends keys to the Window. Refer to specific adapter's documentation for possible values.
     #
     # Raises an UnknownWindowException if the Window itself doesn't exist.
-    def send_keys(keys)
+    def send_keys(*keys)
       wait_until_exists
-      @window.send_keys(keys)
+      @window.send_keys(*keys)
     end
 
     # Closes the Window if it exists.
@@ -158,7 +158,7 @@ module RAutomation
     end
 
     # Returns the Button object by the _locators_ on the Window.
-    # Refer to specific implementation's documentation for possible parameters.
+    # Refer to specific adapter's documentation for possible parameters.
     #
     # Raises an UnknownWindowException if the Window itself doesn't exist.
     def button(locators)
@@ -167,7 +167,7 @@ module RAutomation
     end
 
     # Returns the TextField object by the _locators_ on the Window.
-    # Refer to specific implementation's documentation for possible parameters.
+    # Refer to specific adapter's documentation for possible parameters.
     #
     # Raises an UnknownWindowException if the Window itself doesn't exist.
     def text_field(locators)
@@ -175,9 +175,9 @@ module RAutomation
       TextField.new(@window, locators)
     end
 
-    # Allow to execute implementation's methods not part of the public API
+    # Allow to execute adapter's methods not part of the public API
     def method_missing(name, *args)
-      @window.respond_to?(name) ? @window.send(name, *args) : super
+      @window.send(name, *args)
     end
 
     private
@@ -185,7 +185,11 @@ module RAutomation
     def wait_until_exists
       WaitHelper.wait_until(RAutomation::Window.wait_timeout) {exists?}
     rescue WaitHelper::TimeoutError
-      raise UnknownWindowException.new("Window with locator #{@window.locators.inspect} doesn't exist!") unless exists?
+      raise UnknownWindowException, "Window with locator #{@window.locators.inspect} doesn't exist!" unless exists?
+    end
+
+    def normalize adapter
+      adapter.to_s.split("_").map {|word| word.capitalize}.join
     end
 
   end

data/rautomation.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rautomation}
-  s.version = "0.0.4"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jarmo Pertman"]
-  s.date = %q{2010-10-27}
+  s.date = %q{2010-12-14}
   s.description = %q{RAutomation tries to be a small and easy to use library for helping out to automate windows and their controls
 for automated testing.
 
@@ -17,7 +17,7 @@ RAutomation aims to provide:
 * Easy to use and user-friendly API (inspired by Watir http://www.watir.com).
 * Cross-platform compatibility
 * Easy extensibility - have some application, which uses some specialized technology, but isn't supported by RAutomation?
-  You can get dirty and create new implementation for RAutomation, due to the applied Strategy Pattern!}
+  You can get dirty and create a new adapter for RAutomation!}
   s.email = %q{jarmo.p@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -26,6 +26,7 @@ RAutomation aims to provide:
   s.files = [
     ".document",
      ".gitignore",
+     ".rspec",
      "History.rdoc",
      "LICENSE",
      "README.rdoc",
@@ -34,19 +35,25 @@ RAutomation aims to provide:
      "ext/AutoItX/AutoItX.chm",
      "ext/AutoItX/AutoItX3.dll",
      "lib/rautomation.rb",
+     "lib/rautomation/adapter/autoit.rb",
+     "lib/rautomation/adapter/autoit/button.rb",
+     "lib/rautomation/adapter/autoit/locators.rb",
+     "lib/rautomation/adapter/autoit/text_field.rb",
+     "lib/rautomation/adapter/autoit/window.rb",
+     "lib/rautomation/adapter/ffi.rb",
+     "lib/rautomation/adapter/ffi/button.rb",
+     "lib/rautomation/adapter/ffi/constants.rb",
+     "lib/rautomation/adapter/ffi/functions.rb",
+     "lib/rautomation/adapter/ffi/locators.rb",
+     "lib/rautomation/adapter/ffi/text_field.rb",
+     "lib/rautomation/adapter/ffi/window.rb",
+     "lib/rautomation/adapter/helper.rb",
      "lib/rautomation/button.rb",
-     "lib/rautomation/implementations/autoit.rb",
-     "lib/rautomation/implementations/autoit/button.rb",
-     "lib/rautomation/implementations/autoit/locators.rb",
-     "lib/rautomation/implementations/autoit/text_field.rb",
-     "lib/rautomation/implementations/autoit/window.rb",
-     "lib/rautomation/implementations/helper.rb",
      "lib/rautomation/text_field.rb",
      "lib/rautomation/wait_helper.rb",
      "lib/rautomation/window.rb",
      "rautomation.gemspec",
      "spec/button_spec.rb",
-     "spec/spec.opts",
      "spec/spec_helper.rb",
      "spec/test.html",
      "spec/text_field_spec.rb",
@@ -69,12 +76,12 @@ RAutomation aims to provide:
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3"])
     else
-      s.add_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3"])
     end
   else
-    s.add_dependency(%q<rspec>, [">= 1.3.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3"])
   end
 end
 

data/spec/spec_helper.rb

@@ -1,20 +1,19 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'rautomation'
-require 'spec'
-require 'spec/autorun'
+require 'rspec'
 
 module SpecHelper
-  # Since implementations are different then the windows to be tested
+  # Since adapters are different then the windows to be tested
   # might be different also.
   #
-  # This constant allows to create input data for specs which could differ between the implementations.
+  # This constant allows to create input data for specs which could differ between the adapters.
   #
   # There has to be 2 windows:
   # 1) Some random window, which is maximizable, minimizable, close'able and etc.
   # 2) Browser window, which opens up a test.html where JavaScript prompt with a Button and a TextField objects will be shown.
   DATA = {
-          # This implementation needs Windows OS with Internet Explorer installed into 'c:\program files\internet explorer'.
-          "RAutomation::Implementations::AutoIt::Window" => {
+          # This adapter needs Windows OS with Internet Explorer installed into 'c:\program files\internet explorer'.
+          :autoit => {
                   # Path to some binary, which opens up a window, what can be
                   # minimized, maximized, activated, closed and etc.
                   :window1 => "mspaint",
@@ -31,12 +30,35 @@ module SpecHelper
                   # Window 2 should have a button with the following text.
                   :window2_button_text => "OK",
                   # Window 2 should have a text field with the specified class name.
-                  :window2_text_field_class_name => "Edit1"
+                  :window2_text_field_class => "Edit",
+                  :title_proc => lambda {|win| win.WinGetTitle("[TITLE:Explorer User Prompt]")}
+          },
+          # This adapter needs Windows OS with Internet Explorer installed into 'c:\program files\internet explorer'.
+          :ffi => {
+                  # Path to some binary, which opens up a window, what can be
+                  # minimized, maximized, activated, closed and etc.
+                  :window1 => "mspaint",
+                  # Window 1 title, has to be a Regexp.
+                  :window1_title => /untitled - paint/i,
+                  # Path to some browser's binary.
+                  :window2 => '"c:\\program files\\internet explorer\\iexplore.exe"',
+                  # Window 2 title, has to be a String.
+                  :window2_title => "Explorer User Prompt",
+                  # Window 2 should have this text on it.
+                  :window2_text => "Where do you want to go today?",
+                  # When sending ENTER on Window 2, then the window OK button should be pressed and Window 2 should be closed.
+                  # VK_RETURN
+                  :window2_send_keys => 0xD,
+                  # Window 2 should have a button with the following text.
+                  :window2_button_text => "OK",
+                  # Window 2 should have a text field with the specified class name.
+                  :window2_text_field_class => "Edit",
+                  :title_proc => lambda {|win| win.window_title(win.hwnd)}
           }
-  }[ENV["RAUTOMATION_IMPLEMENTATION"] || RAutomation::Implementations::Helper.default_implementation.to_s]
+  }[ENV["RAUTOMATION_ADAPTER"] && ENV["RAUTOMATION_ADAPTER"].to_sym || RAutomation::Adapter::Helper.default_adapter]
 end
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.before(:all) do
     @pid1 = IO.popen(SpecHelper::DATA[:window1]).pid
     @pid2 = IO.popen(SpecHelper::DATA[:window2] + " " + File.dirname(__FILE__) + "/test.html").pid

data/spec/text_field_spec.rb

@@ -3,51 +3,51 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe RAutomation::TextField do
   it "#text_field" do
     RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).
-            text_field(:class_name => SpecHelper::DATA[:window2_text_field_class_name]).should exist
+            text_field(:class => SpecHelper::DATA[:window2_text_field_class]).should exist
 
     RAutomation::Window.wait_timeout = 0.1
     lambda {RAutomation::Window.new(:title => "non-existent-window").
-            text_field(:class_name => SpecHelper::DATA[:window2_text_field_class_name])}.
+            text_field(:class => SpecHelper::DATA[:window2_text_field_class])}.
             should raise_exception(RAutomation::UnknownWindowException)
   end
 
   it "#set" do
     window = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
-    window.text_field(:class_name => SpecHelper::DATA[:window2_text_field_class_name]).set "hello!"
+    window.text_field(:class => SpecHelper::DATA[:window2_text_field_class]).set "hello!"
 
     RAutomation::Window.wait_timeout = 0.1
-    lambda {window.text_field(:class_name => "non-existing-field").set "hello!"}.
+    lambda {window.text_field(:class => "non-existing-field").set "hello!"}.
             should raise_exception(RAutomation::UnknownTextFieldException)
   end
 
   it "#clear"do
     window = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
-    field = window.text_field(:class_name => SpecHelper::DATA[:window2_text_field_class_name])
+    field = window.text_field(:class => SpecHelper::DATA[:window2_text_field_class])
     field.set "hello!"
     field.value.should == "hello!"
     field.clear
     field.value.should be_empty
 
     RAutomation::Window.wait_timeout = 0.1
-    lambda {window.text_field(:class_name => "non-existent-field").clear}.
+    lambda {window.text_field(:class => "non-existent-field").clear}.
             should raise_exception(RAutomation::UnknownTextFieldException)
   end
 
   it "#value" do
     window = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
-    field = window.text_field(:class_name => SpecHelper::DATA[:window2_text_field_class_name])
+    field = window.text_field(:class => SpecHelper::DATA[:window2_text_field_class])
     field.set "hello!"
     field.value.should == "hello!"
 
     RAutomation::Window.wait_timeout = 0.1
-    lambda {window.text_field(:class_name => "non-existent-field").value}.
+    lambda {window.text_field(:class => "non-existent-field").value}.
             should raise_exception(RAutomation::UnknownTextFieldException)
   end
 
   it "#exists?" do
     window = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
-    field = window.text_field(:class_name => SpecHelper::DATA[:window2_text_field_class_name])
+    field = window.text_field(:class => SpecHelper::DATA[:window2_text_field_class])
     field.should exist
-    window.text_field(:class_name => "non-existent-field").should_not exist
+    window.text_field(:class => "non-existent-field").should_not exist
   end
 end

data/spec/window_spec.rb

@@ -9,8 +9,8 @@ describe RAutomation::Window do
     RAutomation::WaitHelper.wait_until {window.present?}
   end
 
-  it "RAutomation::Window.implementation" do
-    RAutomation::Window.new(:title => "random").implementation.should == (ENV["RAUTOMATION_IMPLEMENTATION"] || RAutomation::Implementations::Helper.default_implementation)
+  it "RAutomation::Window.adapter" do
+    RAutomation::Window.new(:title => "random").adapter.should == (ENV["RAUTOMATION_ADAPTER"] && ENV["RAUTOMATION_ADAPTER"].to_sym || RAutomation::Adapter::Helper.default_adapter)
   end
 
   it "Window#new by full title" do
@@ -102,6 +102,11 @@ describe RAutomation::Window do
             should raise_exception(RAutomation::UnknownWindowException)
   end
 
+  it "#method_missing" do
+    win = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
+    SpecHelper::DATA[:title_proc].call(win).should == SpecHelper::DATA[:window2_title]
+  end
+
   it "#send_keys"do
     window = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
     window.minimize # #send_keys should work even if window is minimized

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rautomation
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 4
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors: 
 - Jarmo Pertman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-27 00:00:00 +03:00
+date: 2010-12-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,14 +24,13 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 5
         segments: 
-        - 1
+        - 2
         - 3
-        - 0
-        version: 1.3.0
+        version: "2.3"
   type: :development
   version_requirements: *id001
 description: |-
@@ -42,7 +41,7 @@ description: |-
   * Easy to use and user-friendly API (inspired by Watir http://www.watir.com).
   * Cross-platform compatibility
   * Easy extensibility - have some application, which uses some specialized technology, but isn't supported by RAutomation?
-    You can get dirty and create new implementation for RAutomation, due to the applied Strategy Pattern!
+    You can get dirty and create a new adapter for RAutomation!
 email: jarmo.p@gmail.com
 executables: []
 
@@ -54,6 +53,7 @@ extra_rdoc_files:
 files: 
 - .document
 - .gitignore
+- .rspec
 - History.rdoc
 - LICENSE
 - README.rdoc
@@ -62,19 +62,25 @@ files:
 - ext/AutoItX/AutoItX.chm
 - ext/AutoItX/AutoItX3.dll
 - lib/rautomation.rb
+- lib/rautomation/adapter/autoit.rb
+- lib/rautomation/adapter/autoit/button.rb
+- lib/rautomation/adapter/autoit/locators.rb
+- lib/rautomation/adapter/autoit/text_field.rb
+- lib/rautomation/adapter/autoit/window.rb
+- lib/rautomation/adapter/ffi.rb
+- lib/rautomation/adapter/ffi/button.rb
+- lib/rautomation/adapter/ffi/constants.rb
+- lib/rautomation/adapter/ffi/functions.rb
+- lib/rautomation/adapter/ffi/locators.rb
+- lib/rautomation/adapter/ffi/text_field.rb
+- lib/rautomation/adapter/ffi/window.rb
+- lib/rautomation/adapter/helper.rb
 - lib/rautomation/button.rb
-- lib/rautomation/implementations/autoit.rb
-- lib/rautomation/implementations/autoit/button.rb
-- lib/rautomation/implementations/autoit/locators.rb
-- lib/rautomation/implementations/autoit/text_field.rb
-- lib/rautomation/implementations/autoit/window.rb
-- lib/rautomation/implementations/helper.rb
 - lib/rautomation/text_field.rb
 - lib/rautomation/wait_helper.rb
 - lib/rautomation/window.rb
 - rautomation.gemspec
 - spec/button_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 - spec/test.html
 - spec/text_field_spec.rb

data/spec/spec.opts

@@ -1,2 +0,0 @@
---color
---format n