rautomation 2.0.1-x64-mingw32

data/lib/rautomation/adapter/win_32/select_list.rb

@@ -0,0 +1,97 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class SelectList < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /combobox/i}
+
+        class SelectListOption
+          attr_accessor :text, :index
+
+          def initialize(select_list, text, index)
+            @select_list = select_list
+            @text        = text
+            @index       = index
+          end
+
+          def selected?
+            selected_idx = Functions.send_message(@select_list.hwnd, Constants::CB_GETCURSEL, 0, nil)
+            return false if selected_idx == Constants::CB_ERR
+            @text == Functions.retrieve_combobox_item_text(@select_list.hwnd, selected_idx)
+          end
+
+          def select
+            @select_list.send :assert_enabled
+            Functions.send_message(@select_list.hwnd, Constants::CB_SETCURSEL, @index, nil) != Constants::CB_ERR
+          end
+
+          alias_method :set, :select
+        end
+
+        def options(options = {})
+          items = []
+
+          item_count.times do |item_no|
+            item = Functions.retrieve_combobox_item_text(hwnd, item_no)
+
+            if options[:text]
+              items.push(SelectListOption.new(self, item, item_no)) if options[:text] == item
+            else
+              items.push(SelectListOption.new(self, item, item_no))
+            end
+          end
+
+          items
+        end
+
+        def value
+          selected_option = options.find { |option| option.selected? }
+          selected_option ? selected_option.text : ""
+        end
+
+        def option(options)
+          item_count.times do |item_no|
+            item = Functions.retrieve_combobox_item_text(hwnd, item_no)
+            return SelectListOption.new(self, item, item_no) if options[:text] == item
+          end
+
+          nil
+        end
+
+        def select(index)
+          Functions.send_message(hwnd, Constants::CB_SETCURSEL, index, nil) != Constants::CB_ERR
+        end
+
+        def set(text)
+          option(:text => text).set
+        end
+
+        def list_item_height
+          Functions.send_message(hwnd, Constants::CB_GETITEMHEIGHT, 0 ,nil)
+        end
+
+        def dropbox_boundary
+          boundary = FFI::MemoryPointer.new :long, 4
+
+          Functions.send_message(hwnd, Constants::CB_GETDROPPEDCONTROLRECT, 0 ,boundary)
+
+          boundary.read_array_of_long(4)
+        end
+
+        def get_top_index
+          Functions.send_message(hwnd, Constants::CB_GETTOPINDEX, 0 ,nil)
+        end
+
+        private
+
+        def item_count
+          Functions.send_message(hwnd, Constants::CB_GETCOUNT, 0, nil)
+        end
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_32/table.rb

@@ -0,0 +1,25 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Table < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /syslistview/i}
+
+        def select(row)
+          Functions.select_table_row(Window.oleacc_module_handle, Functions.control_hwnd(@window.hwnd, @locators), row)
+        end
+
+        def selected?(row)
+          handle = Window.oleacc_module_handle
+          control_hwnd = Functions.control_hwnd(@window.hwnd, @locators)
+
+          state = Functions.get_table_row_state(handle, control_hwnd, row)
+          state & Constants::STATE_SYSTEM_SELECTED != 0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class TextField < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching text fields.
+        DEFAULT_LOCATORS = {:class => /edit/i}
+
+        # @see RAutomation::TextField#set
+        def set(text)
+          assert_enabled
+
+          wait_until do
+            hwnd = Functions.control_hwnd(@window.hwnd, @locators)
+            @window.activate
+            @window.active? &&
+                    focus &&
+                    Functions.set_control_text(hwnd, text) &&
+                    set?(text)
+          end
+        end
+
+        # @see RAutomation::TextField#clear
+        def clear
+          assert_enabled
+          set ""
+        end
+
+        # @see RAutomation::Window#send_keys
+        def send_keys(*keys)
+          @window.container.wait_until_present
+          assert_enabled
+          @window.activate
+          focus
+          @window.send_keys(keys)
+        end
+
+        private
+
+        def set?(text)
+          value == text
+        end
+
+        def assert_enabled
+          raise "Cannot set value on a disabled text field" if disabled?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,277 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Window
+        include WaitHelper
+        include Locators
+        extend ElementCollections
+
+        has_many :controls
+
+        class << self
+          def oleacc_module_handle
+            @oleacc_module_handle ||= begin
+              oleacc = Functions.load_library("oleacc.dll")
+              Functions.co_initialize nil
+              oleacc
+            end
+          end
+        end
+
+        attr_reader :container
+
+        # Locators of the window.
+        attr_reader :locators
+
+        # Possible locators are :title, :text, :hwnd, :pid, :class and :index.
+
+        # Creates the window object.
+        # @note this method is not meant to be accessed directly, but only through {RAutomation::Window#initialize}!
+        # @param [Hash] locators for searching the window.
+        # @option locators [String, Regexp] :title Title of the window
+        # @option locators [String, Regexp] :text Visible text of the window
+        # @option locators [String, Regexp] :class Internal class name of the window
+        # @option locators [String, Integer] :hwnd Window handle in decimal format
+        # @option locators [String, Integer] :pid Window process ID (PID)
+        # @option locators [String, Integer] :index 0-based index to specify n-th window if all other criteria match
+        #   all other criteria match
+        # @see RAutomation::Window#initialize
+        def initialize(container, locators)
+          @container = container
+          extract(locators)
+        end
+
+        # Retrieves handle of the window.
+        # @note Searches only for visible windows.
+        # @see RAutomation::Window#hwnd
+        def hwnd
+          @hwnd ||= Functions.window_hwnd(@locators)
+        end
+
+        # @see RAutomation::Window#pid
+        def pid
+          Functions.window_pid(hwnd)
+        end
+
+        # @see RAutomation::Window#title
+        def title
+          Functions.window_title(hwnd)
+        end
+
+        # @see RAutomation::Window#class_names
+        def class_names
+          classes = []
+          controls.each do |control|
+            classes << control.class_name
+          end
+          classes.sort
+        end
+
+        # @see RAutomation::Window#activate
+        def activate
+          return if !exists? || active?
+          restore if minimized?
+          Functions.activate_window(hwnd)
+          sleep 0.1
+        end
+
+        # @see RAutomation::Window#active?
+        def active?
+          exists? && Functions.foreground_window == hwnd
+        end
+
+        # @see RAutomation::Window#text
+        def text
+          Functions.window_text(hwnd)
+        end
+
+        # @see RAutomation::Window#exists?
+        def exists?
+          result = hwnd && Functions.window_exists(hwnd)
+          !!result
+        end
+
+        # @see RAutomation::Window#visible?
+        def visible?
+          Functions.window_visible(hwnd)
+        end
+
+        # @see RAutomation::Window#maximize
+        def maximize
+          Functions.show_window(hwnd, Constants::SW_MAXIMIZE)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#minimize
+        def minimize
+          Functions.show_window(hwnd, Constants::SW_MINIMIZE)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#minimized?
+        def minimized?
+          Functions.minimized(hwnd)
+        end
+
+        # @see RAutomation::Window#restore
+        def restore
+          Functions.show_window(hwnd, Constants::SW_RESTORE)
+          sleep 1
+        end
+
+        # Moves/resizes the window. 
+        # @note All coordinates are optional and if not specified current coordinates will be used
+        # @param [Hash] coords for specifying the coordinates.
+        # @option coords [Integer] :left Window coordinate from the left side of screen
+        # @option coords [Integer] :top Window coordinate from the top of the screen
+        # @option coords [Integer] :width Width of window
+        # @option coords [Integer] :height Height of window
+        def move(coords={})
+          @container.wait_until_present
+          rect = dimensions.merge(coords)
+          Functions.move_window(hwnd, rect[:left], rect[:top], rect[:width], rect[:height])
+          sleep 1
+        end
+
+        # @return [Hash] Hash[:left, :top, :width, :height] with window coordinates
+        def dimensions
+          @container.wait_until_present
+          left, top, right, bottom = Functions.window_rect(hwnd)
+          {:left => left, :top => top, :width => right - left, :height => bottom - top}
+        end
+
+
+        # Activates the window and sends keys to it.
+        #
+        # @example
+        #   RAutomation::Window.new(:title => //).send_keys "hello!"
+        #   RAutomation::Window.new(:title => //).send_keys [:control, "a"], "world!"
+        # Refer to {Keys::KEYS} for all the special keycodes.
+        # @see RAutomation::Window#send_keys
+        def send_keys(args)
+          Keys.encode(args).each do |arg|
+            wait_until do
+              activate
+              active?
+            end
+
+            if arg.is_a?(Array)
+              arg.reduce([]) do |pressed_keys, k|
+                if k == Keys[:null]
+                  pressed_keys.each {|pressed_key| release_key pressed_key}
+                  pressed_keys = []
+                else
+                  pressed_keys << press_key(k)
+                end
+                pressed_keys
+              end
+            else
+              send_key arg
+            end
+          end
+          sleep 1
+        end
+
+        # @see RAutomation::Window#close
+        def close
+          Functions.close_window(hwnd)
+        end
+
+        # Retrieves the {Mouse} object for automating mouse movements and clicks
+        # @raise [UnknownWindowException] if the window doesn't exist.
+        def mouse
+          @container.wait_until_present
+          Mouse.new(self)
+        end
+
+        # @see Button#initialize
+        # @see RAutomation::Window#button
+        def button(locator)
+          Button.new(self, locator)
+        end
+
+        # @see TextField#initialize
+        # @see RAutomation::Window#text_field
+        def text_field(locator)
+          TextField.new(self, locator)
+        end
+
+        # Redirects all method calls not part of the public API to the {Functions} directly.
+        # @see RAutomation::Window#method_missing
+        def method_missing(name, *args)
+          Functions.respond_to?(name) ? Functions.send(name, *args) : super
+        end
+
+        # Win32 adapter specific API methods
+        def label(locator={})
+          @container.wait_until_present
+          Label.new(self, locator)
+        end
+
+        def password_field(locator)
+          @container.wait_until_present
+          PasswordField.new(self, locator)
+        end
+
+        def control(locator={})
+          @container.wait_until_present
+          Control.new(self, locator)
+        end
+
+        def list_box(locator={})
+          @container.wait_until_present
+          ListBox.new(self, locator)
+        end
+
+        def select_list(locator={})
+          @container.wait_until_present
+          SelectList.new(self, locator)
+        end
+
+        def checkbox(locator={})
+          @container.wait_until_present
+          Checkbox.new(self, locator)
+        end
+
+        def radio(locator={})
+          @container.wait_until_present
+          Radio.new(self, locator)
+        end
+
+        def table(locator={})
+          @container.wait_until_present
+          Table.new(self, locator)
+        end
+
+        # Creates the child window object.
+        # @note This is an Win32 adapter specific method, not part of the public API
+        # @example
+        #   RAutomation::Window.new(:title => /Windows Internet Explorer/i).
+        #     child(:title => /some popup/)
+        # @param (see Window#initialize)
+        # @return [RAutomation::Window] child window, popup or regular window.
+        def child(locators)
+          RAutomation::Window.new Functions.child_window_locators(hwnd, locators)
+        end
+
+        private
+
+        def press_key key
+          Functions.send_key(key, 0, 0, nil)
+          key
+        end
+
+        def release_key key
+          Functions.send_key(key, 0, Constants::KEYEVENTF_KEYUP, nil)
+          key
+        end
+
+        def send_key key
+          press_key key
+          release_key key
+          key
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_32.rb

@@ -0,0 +1,23 @@
+begin
+  gem "ffi"
+rescue Gem::LoadError
+  raise Gem::LoadError, "Unable to load FFI gem. Install it with:\n\tgem install ffi"
+end
+require "ffi"
+require File.dirname(__FILE__) + "/win_32/constants"
+require File.dirname(__FILE__) + "/win_32/keys"
+require File.dirname(__FILE__) + "/win_32/functions"
+require File.dirname(__FILE__) + "/win_32/locators"
+require File.dirname(__FILE__) + "/win_32/window"
+require File.dirname(__FILE__) + "/win_32/button_helper"
+require File.dirname(__FILE__) + "/win_32/control"
+require File.dirname(__FILE__) + "/win_32/button"
+require File.dirname(__FILE__) + "/win_32/checkbox"
+require File.dirname(__FILE__) + "/win_32/radio"
+require File.dirname(__FILE__) + "/win_32/text_field"
+require File.dirname(__FILE__) + "/win_32/select_list"
+require File.dirname(__FILE__) + "/win_32/table"
+require File.dirname(__FILE__) + "/win_32/label"
+require File.dirname(__FILE__) + "/win_32/list_box"
+require File.dirname(__FILE__) + "/win_32/mouse"
+require File.dirname(__FILE__) + "/win_32/password_field"

data/lib/rautomation/button.rb

@@ -0,0 +1,55 @@
+module RAutomation
+  class Button
+    # @private
+    # This constructor is meant to be accessed only through {Window#button} method.
+    def initialize(window, locators)
+      @window = window
+      @locators = locators
+      @button = @window.button(@locators)
+    end
+
+    # Performs a click on the button.
+    # By default click is considered successful if the button doesn't exist after clicking (e.g. window has closed)
+    # @yield [button] optional block specifying successful clicking condition.
+    # @yieldparam [Button] button which is being clicked on.
+    # @yieldreturn [Boolean] true if clicking on the button is successful, false otherwise.
+    # @raise [UnknownButtonException] if the button doesn't exist.
+    def click
+      wait_until_exists
+      if block_given?
+        @button.click {yield self}
+      else
+        @button.click
+      end
+    end
+
+    # Retrieves the value (text) of the button, usually the visible text.
+    # @return [String] the value (text) of the button.
+    # @raise [UnknownButtonException] if the button doesn't exist.
+    def value
+      wait_until_exists
+      @button.value
+    end
+
+    # Checks if the button exists.
+    # @return [Boolean] true if button exists, false otherwise.
+    def exists?
+      @button.exists?
+    end
+
+    alias_method :exist?, :exists?
+
+    # Allows to execute specific {Adapter} methods not part of the public API.
+    def method_missing(name, *args)
+      @button.send(name, *args)
+    end
+
+    private
+
+    def wait_until_exists
+      WaitHelper.wait_until {exists?}
+    rescue WaitHelper::TimeoutError
+      raise UnknownButtonException, "Button #{@locators.inspect} doesn't exist on window #{@window.locators.inspect}!"
+    end
+  end
+end

data/lib/rautomation/element_collections.rb

@@ -0,0 +1,55 @@
+module RAutomation
+  # @private
+  module ElementCollections
+    class UnsupportedLocatorException < RuntimeError
+    end
+
+    # Creates collection classes and methods for elements.
+    # @param [Array<Symbol>] elements for which to create collection classes
+    #   and methods.
+    def has_many(*elements)
+      elements.each do |element|
+        class_name_plural = element.to_s.split("_").map {|e| e.capitalize}.join
+        class_name = class_name_plural.chop
+        adapter_class = self.to_s.scan(/(.*)::/).flatten.first
+        clazz = RAutomation.constants.include?(class_name) ? RAutomation : class_eval(adapter_class)
+        clazz.class_eval %Q{
+            class #{class_name_plural}
+              include Enumerable
+
+              def initialize(window, locators)
+               if locators[:hwnd] || locators[:pid]
+                raise UnsupportedLocatorException, 
+                  ":hwnd or :pid in " + locators.inspect + " are not supported for #{adapter_class}::#{class_name_plural}"
+                end
+
+                @window = window
+                @locators = locators
+              end
+
+              def each
+                i = -1 
+                while true
+                  args = [@window, @locators.merge(:index => i += 1)].compact
+                  object = #{clazz}::#{class_name}.new(*args)
+                  break unless object.exists?
+                  yield object
+                end
+              end
+
+              def method_missing(name, *args)
+                ary = self.to_a
+                ary.respond_to?(name) ? ary.send(name, *args) : super
+              end
+            end
+        }
+
+        class_eval %Q{
+            def #{element}(locators = {})
+              #{adapter_class}::#{class_name_plural}.new(@window || self, locators)
+            end
+        }
+      end
+    end
+  end
+end

data/lib/rautomation/platform.rb

@@ -0,0 +1,15 @@
+module Platform
+   extend self
+
+   def architecture
+      if is_x86?
+         'x86'
+      else
+         'x64'
+      end
+   end
+
+   def is_x86?
+      %w[x86 i386].any? { |p| RUBY_PLATFORM =~ /#{p}/i }
+   end
+end

data/lib/rautomation/text_field.rb

@@ -0,0 +1,60 @@
+module RAutomation
+  class TextField
+    # @private
+    # This constructor is meant to be accessed only through {Window#text_field} method.
+    def initialize(window, locators) #:nodoc:
+      @window = window
+      @locators = locators
+      @text_field = @window.text_field(@locators)
+    end
+
+    # Sets text of the text field.
+    # @param [String] text of the field to set.
+    # @raise [UnknownTextFieldException] if the text field doesn't exist.
+    def set(text)
+      wait_until_exists
+      @text_field.set(text)
+    end
+
+    # Clears text field's text.
+    # @raise [UnknownTextFieldException] if the text field doesn't exist.
+    def clear
+      wait_until_exists
+      @text_field.clear
+    end
+
+    # Returns text field's current value (text).
+    # @return [String] the value (text) of the text field.
+    # @raise [UnknownTextFieldException] if the text field doesn't exist.
+    def value
+      wait_until_exists
+      @text_field.value
+    end
+
+    # Checks if the text field exists.
+    # @return [Boolean] true if text field exists, false otherwise.
+    def exists?
+      @text_field.exists?
+    end
+
+    def hwnd
+      wait_until_exists
+      @text_field.hwnd
+    end
+
+    alias_method :exist?, :exists?
+
+    # Allows to execute specific {Adapter} methods not part of the public API.
+    def method_missing(name, *args)
+      @text_field.send(name, *args)
+    end
+
+    private
+
+    def wait_until_exists
+      WaitHelper.wait_until {exists?}
+    rescue WaitHelper::TimeoutError
+      raise UnknownTextFieldException, "Text field #{@locators.inspect} doesn't exist on window #{@window.locators.inspect}!" unless exists?
+    end
+  end
+end

data/lib/rautomation/version.rb

@@ -0,0 +1,3 @@
+module RAutomation
+  VERSION = "2.0.1"
+end

data/lib/rautomation/wait_helper.rb

@@ -0,0 +1,23 @@
+module RAutomation
+  # Waiting with timeout
+  module WaitHelper
+    extend self
+    
+    class TimeoutError < StandardError
+    end
+
+    # @private
+    # Wait until the block evaluates to true or times out.
+    def wait_until(timeout = Window.wait_timeout, &block)
+      end_time = ::Time.now + timeout
+
+      until ::Time.now > end_time
+        result = yield(self)
+        return result if result
+        sleep 0.5
+      end
+
+      raise TimeoutError, "timed out after #{timeout} seconds"
+    end
+  end
+end