rautomation 0.6.3 → 0.7.0

data/lib/rautomation/adapter/win_ffi.rb

@@ -1,21 +0,0 @@
-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_ffi/constants"
-require File.dirname(__FILE__) + "/win_ffi/keystroke_converter"
-require File.dirname(__FILE__) + "/win_ffi/functions"
-require File.dirname(__FILE__) + "/win_ffi/locators"
-require File.dirname(__FILE__) + "/win_ffi/window"
-require File.dirname(__FILE__) + "/win_ffi/button_helper"
-require File.dirname(__FILE__) + "/win_ffi/control"
-require File.dirname(__FILE__) + "/win_ffi/button"
-require File.dirname(__FILE__) + "/win_ffi/checkbox"
-require File.dirname(__FILE__) + "/win_ffi/radio"
-require File.dirname(__FILE__) + "/win_ffi/text_field"
-require File.dirname(__FILE__) + "/win_ffi/select_list"
-require File.dirname(__FILE__) + "/win_ffi/table"
-require File.dirname(__FILE__) + "/win_ffi/label"
-require File.dirname(__FILE__) + "/win_ffi/list_box"

data/lib/rautomation/adapter/win_ffi/checkbox.rb

@@ -1,19 +0,0 @@
-module RAutomation
-  module Adapter
-    module WinFfi
-      class Checkbox < Control
-        include WaitHelper
-        include Locators
-        include ButtonHelper
-
-
-        def exist?
-          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_CHECKBOX_CONTROL_TYPE)
-        end
-
-        alias_method :exists?, :exist?
-
-      end
-    end
-  end
-end

data/lib/rautomation/adapter/win_ffi/keystroke_converter.rb

@@ -1,67 +0,0 @@
-module RAutomation
-  module Adapter
-    module WinFfi
-      class KeystrokeConverter
-        class << self
-          def convert(str)
-            special_characters = ""
-
-            str.split(/([{}])/).inject([]) do |converted_keys, str|
-              if str == "}"
-                converted_keys << convert_special_characters(special_characters << str)
-                special_characters = ""
-              elsif str == "{" || !special_characters.empty?
-                special_characters << str
-              else
-                converted_keys += convert_characters(str)
-              end
-              converted_keys
-            end.flatten
-          end
-
-          private
-
-          def convert_special_characters chars
-            case chars.downcase
-            when "{tab}"
-              Constants::VK_TAB
-            when "{backspace}"
-              Constants::VK_BACK
-            when "{enter}"
-              Constants::VK_RETURN
-            when "{left}"
-              Constants::VK_LEFT
-            when "{right}"
-              Constants::VK_RIGHT
-            when "{down}"
-              Constants::VK_DOWN
-            when "{up}"
-              Constants::VK_UP
-            else
-              # unsupported special tag, ignore the tag itself, but convert the
-              # characters inside the tag
-              convert_characters(chars.gsub(/[{}]/, ""))
-            end
-          end
-
-          private
-
-          def convert_characters(element)
-            element.split(//).inject([]) do |chars, char|
-              char_code = char.upcase.unpack("c")[0]
-              if char =~ /[A-Z]/
-                chars += in_upcase(char_code)
-              else
-                chars << char_code
-              end
-            end
-          end
-
-          def in_upcase(char_code)
-            [Constants::VK_LSHIFT, char_code]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rautomation/adapter/win_ffi/list_box.rb

@@ -1,60 +0,0 @@
-module RAutomation
-  module Adapter
-    module WinFfi
-
-      class ListBox < Control
-        include WaitHelper
-        include Locators
-
-        def count
-          UiaDll::find_children(uia_control(@locators[:id]), nil)
-        end
-
-        def items
-          list_items = []
-          children = FFI::MemoryPointer.new :pointer, self.count
-          length = UiaDll::find_children(uia_control(@locators[:id]), children)
-          children.read_array_of_pointer(length).each do |child|
-            child_name = FFI::MemoryPointer.new :char, UiaDll::get_name(child, nil) + 1
-            UiaDll::get_name(child, child_name)
-            list_items.push child_name.read_string
-          end
-          list_items
-        end
-
-        def exist?
-          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_LIST_CONTROL_TYPE)
-        end
-
-        alias_method :exists?, :exist?
-
-        def selected?(index)
-          children = FFI::MemoryPointer.new :pointer, self.count
-          length = UiaDll::find_children(uia_control(@locators[:id]), children)
-          target_element = children.read_array_of_pointer(length)[index]
-          is_selected = FFI::MemoryPointer.new :int, 1
-
-          if UiaDll::get_is_selected(target_element, is_selected) == 1
-            return is_selected.read_int == 1
-          else
-            return false
-          end
-        end
-
-        def select(index)
-          children = FFI::MemoryPointer.new :pointer, self.count
-
-          length = UiaDll::find_children(uia_control(@locators[:id]), children)
-          target_element = children.read_array_of_pointer(length)[index]
-
-          UiaDll::select(target_element)
-        end
-
-        alias_method :strings, :items
-
-
-      end
-    end
-  end
-end
-

data/lib/rautomation/adapter/win_ffi/ms_uia/uia_dll.rb

@@ -1,36 +0,0 @@
-module RAutomation
-  module Adapter
-    module WinFfi
-      # @private
-      module UiaDll
-        extend FFI::Library
-
-        ffi_lib File.dirname(__FILE__) + '/../../../../../ext/UiaDll/Release/UiaDll.dll'
-        ffi_convention :stdcall
-
-        attach_function :find_window, :RA_FindWindow,
-                        [:string], :pointer
-        attach_function :is_offscreen, :RA_IsOffscreen,
-                        [:pointer], :bool
-        attach_function :element_from_handle, :RA_ElementFromHandle,
-                        [:long], :pointer
-        attach_function :find_child_by_id, :RA_FindChildById,
-                        [:pointer, :string], :pointer
-        attach_function :current_native_window_handle, :RA_CurrentNativeWindowHandle,
-                        [:pointer], :long
-        attach_function :set_focus, :RA_SetFocus,
-                        [:pointer], :bool
-        attach_function :current_control_type, :RA_GetCurrentControlType,
-                        [:pointer], :int
-        attach_function :find_children, :RA_FindChildren,
-                        [:pointer, :pointer], :int
-        attach_function :get_name, :RA_GetName,
-                        [:pointer, :pointer], :int
-        attach_function :get_is_selected, :RA_GetIsSelected,
-                        [:pointer, :pointer], :int
-        attach_function :select, :RA_Select,
-                        [:pointer], :int
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-module RAutomation
-  module Adapter
-    module WinFfi
-      class Table < Control
-        include WaitHelper
-        include Locators
-
-        def strings
-          rows = []
-          header_columns = []
-
-          raise "Not a list control" unless UiaDll::current_control_type(uia_control(@locators[:id])) == Constants::UIA_LIST_CONTROL_TYPE
-
-          children_count = count_children(uia_control(@locators[:id]))
-          children = FFI::MemoryPointer.new :pointer, children_count
-          UiaDll::find_children(uia_control(@locators[:id]), children)
-          children.read_array_of_pointer(children_count).each do |child|
-            grandchildren_count = count_children(child)
-            grandchildren = FFI::MemoryPointer.new :pointer, grandchildren_count
-            UiaDll::find_children(child, grandchildren)
-            grandchildren.read_array_of_pointer(grandchildren_count).each do |grandchild|
-              grandchild_name = FFI::MemoryPointer.new :char, UiaDll::get_name(grandchild, nil) + 1
-              UiaDll::get_name(grandchild, grandchild_name)
-              header_columns.push grandchild_name.read_string
-            end
-
-            rows.push header_columns
-            header_columns = []
-          end
-
-          rows
-        end
-
-        def select(row)
-          Functions.select_table_row(Window.oleacc_module_handle, Functions.control_hwnd(@window.hwnd, @locators), row)
-        end
-
-        def selected?(row)
-          state = Functions.get_table_row_state(Window.oleacc_module_handle, Functions.control_hwnd(@window.hwnd, @locators), row)
-          state & Constants::STATE_SYSTEM_SELECTED != 0
-        end
-
-        def row_count
-          UiaDll::find_children(uia_control(@locators[:id]), nil)
-        end
-
-        private
-
-        def count_children(element)
-          UiaDll::find_children(element, nil)
-        end
-
-
-      end
-    end
-  end
-end

data/spec/adapter/win_ffi/keystroke_converter_spec.rb

@@ -1,47 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'rautomation'
-require 'rspec'
-
-describe "KeystrokeConverter" do
-
-  it "converts plain ASCII" do
-    codes = RAutomation::Adapter::WinFfi::KeystrokeConverter.convert("abc")
-    converted_keys = convert_keys "abc"
-    codes.should == converted_keys
-  end
-
-  it "uses caps lock for entering downcase keys" do
-    codes = RAutomation::Adapter::WinFfi::KeystrokeConverter.convert("aBc")
-    converted_keys = convert_keys "abc"
-    converted_keys = converted_keys.insert(1, RAutomation::Adapter::WinFfi::Constants::VK_LSHIFT)
-    codes.should == converted_keys
-  end
-
-  it "converts special keys" do
-    codes = RAutomation::Adapter::WinFfi::KeystrokeConverter.convert("{tab}a{backspace}b{enter}c {left}d{right}ee{down}f{up}g{unsupported}")
-    expected_codes = [
-      RAutomation::Adapter::WinFfi::Constants::VK_TAB,
-      convert_keys("a"),
-      RAutomation::Adapter::WinFfi::Constants::VK_BACK,
-      convert_keys("b"),
-      RAutomation::Adapter::WinFfi::Constants::VK_RETURN,
-      convert_keys("c"),
-      RAutomation::Adapter::WinFfi::Constants::VK_SPACE,
-      RAutomation::Adapter::WinFfi::Constants::VK_LEFT,
-      convert_keys("d"),
-      RAutomation::Adapter::WinFfi::Constants::VK_RIGHT,
-      convert_keys("ee"),
-      RAutomation::Adapter::WinFfi::Constants::VK_DOWN,
-      convert_keys("f"),
-      RAutomation::Adapter::WinFfi::Constants::VK_UP,
-      convert_keys("g"),
-      convert_keys("unsupported")
-    ].flatten
-    codes.should == expected_codes
-  end
-
-  def convert_keys keys
-    keys.split("").map {|k| k.upcase.unpack("c")[0]}
-  end
-
-end