mohawk 0.1.4 → 0.2

data/lib/mohawk/adapters/uia/text_box.rb

@@ -0,0 +1,47 @@
+module Mohawk
+  module Adapters
+    module UIA
+      class TextBox < Control
+        valid_patterns :text, :value
+
+        def enter(*args)
+          send_keys *args
+        end
+
+        def set(value)
+          if is_value?
+            value_pattern.value = value
+          else
+            text_pattern.text = value
+          end
+        end
+
+        def value
+          return value_pattern.value if is_value?
+          text_pattern.text
+        end
+
+        def clear
+          set ''
+        end
+
+        private
+        def is_value?
+          element.patterns.include? :value
+        end
+
+        def value_pattern
+          element.as :value
+        end
+
+        def is_text?
+          element.patterns.include? :text
+        end
+
+        def text_pattern
+          element.as :text
+        end
+      end
+    end
+  end
+end

data/lib/mohawk/adapters/uia/tree_view.rb

@@ -0,0 +1,22 @@
+module Mohawk
+  module Adapters
+    module UIA
+      class TreeView < SelectList
+        def expand(what)
+          find_element(what).as(:expand_collapse).expand
+        end
+
+        def collapse(what)
+          find_element(what).as(:expand_collapse).collapse
+        end
+
+        def value
+          selected_items.map(&:name).first
+        end
+
+        alias_method :items, :options
+        alias_method :select, :set
+      end
+    end
+  end
+end

data/lib/mohawk/adapters/uia/value_control.rb

@@ -0,0 +1,20 @@
+module Mohawk
+  module Adapters
+    module UIA
+      class ValueControl < Control
+        def set(value)
+          value_pattern.value = value
+        end
+
+        def value
+          value_pattern.value
+        end
+
+        private
+        def value_pattern
+          element.as :value
+        end
+      end
+    end
+  end
+end

data/lib/mohawk/adapters/uia/window.rb

@@ -0,0 +1,64 @@
+require 'uia'
+require 'mohawk/win_32'
+
+module Mohawk
+  module Adapters
+    module UIA
+      class Window
+        include Mohawk::Waiter
+        attr_reader :element
+
+        def initialize(locator, container)
+          @locator = locator
+          @container = container
+        end
+
+        def element
+          @element ||= Uia.find_element(@locator)
+          if @element && @container
+            @element = @element.find(@container) || @element
+          end
+          @element
+        end
+
+        def send_keys(*keys)
+          activate
+          element.send_keys keys
+        end
+
+        def active?
+          Mohawk::Win32.foreground_window == handle
+        end
+
+        def activate
+          Mohawk::Win32.set_foreground_window handle
+          Mohawk::Win32.activate handle
+        end
+
+        def exist?
+          Mohawk::Win32.is_window handle
+        end
+
+        def handle
+          element.handle
+        end
+
+        def title
+          element.name
+        end
+
+        def text
+          element.descendants.map &:name
+        end
+
+        def present?
+          element != nil
+        end
+
+        def wait_until_present
+          wait_until { element }
+        end
+      end
+    end
+  end
+end

data/lib/mohawk/adapters/uia_adapter.rb

@@ -1,91 +1,77 @@
+require 'mohawk/waiter'
+require_rel 'uia'
+
 module Mohawk
   module Adapters
     class UiaAdapter
+      include UIA
+
       def initialize(locator, container=nil)
-        @only_search_children = locator.delete(:children_only)
-        @window = RAutomation::Window.new(locator.merge(:adapter => :ms_uia))
+        @children_only = locator.delete :children_only
+        @locator = locator
         @container = container
       end
 
       def window
-        @actual_window ||= begin
-          if @container
-            control = @window.control(@container)
-            RAutomation::WaitHelper.wait_until { control.exist? }
-            @window = RAutomation::Window.new(:hwnd => control.hwnd, :adapter => :ms_uia)
-          end
-          @window
-        end
+        @window ||= Window.new @locator, @container
       end
 
-      def combo(locator)
-        @combos ||= {}
-        @combos[locator] ||= Mohawk::Accessors::Combo.new(self, merge(locator))
+      def value_control(locator)
+        ValueControl.new self, merge(locator)
       end
 
-
-      def checkbox(locator)
-        @checkbox ||= {}
-        @checkbox[locator] ||= Mohawk::Accessors::CheckBox.new(self, merge(locator))
+      def button(locator)
+        Button.new self, merge(locator)
       end
 
-      def text(locator)
-        @text_fields ||= {}
-        @text_fields[locator] ||= Mohawk::Accessors::Text.new(self, merge(locator))
+      def table(locator)
+        Table.new self, merge(locator)
       end
 
-      def button(locator)
-        @buttons ||= {}
-        @buttons[locator] ||= Mohawk::Accessors::Button.new(self, merge(locator))
+      def checkbox(locator)
+        CheckBox.new self, merge(locator)
       end
 
-      def radio(locator)
-        @radios ||= {}
-        @radios[locator] ||= Mohawk::Accessors::Radio.new(self, merge(locator))
-      end
-	  
-      def label(locator)
-        @labels ||= {}
-        @labels[locator] ||= Mohawk::Accessors::Label.new(self, merge(locator))
+      def combo(locator)
+        SelectList.new self, merge(locator)
       end
 
-      def link(locator)
-        @links ||= {}
-        @links[locator] ||= Mohawk::Accessors::Link.new(self, merge(locator))
+      def tree_view(locator)
+        TreeView.new self, merge(locator)
       end
 
-      def menu_item(locator)
-        Mohawk::Accessors::MenuItem.new(self, merge(locator))
+      def radio(locator)
+        Radio.new self, merge(locator)
       end
 
-      def table(locator)
-        @tables ||= {}
-        @tables[locator] ||= Mohawk::Accessors::Table.new(self, merge(locator))
+      def text(locator)
+        TextBox.new self, merge(locator)
       end
 
-      def tree_view(locator)
-        @trees ||= {}
-        @trees[locator] ||= Mohawk::Accessors::TreeView.new(self, merge(locator))
+      def tab_control(locator)
+        TabControl.new self, merge(locator)
       end
 
-      def value_control(locator)
-        @controls ||= {}
-        @controls[locator] ||= Mohawk::Accessors::Control.new(self, merge(locator))
+      def menu_item(locator)
+        MenuItem.new self, merge(locator)
       end
 
       def spinner(locator)
-        Mohawk::Accessors::Spinner.new(self, merge(locator))
+        Spinner.new self, merge(locator)
       end
 
-      def tab_control(locator)
-        Mohawk::Accessors::Tabs.new(self, merge(locator))
+      def control(locator)
+        Control.new self, merge(locator)
       end
 
+      alias_method :label, :control
+      alias_method :link, :control
+
       private
       def merge(locator)
-        locator = locator.merge(:children_only => true) if @only_search_children
+        locator = locator.merge children_only: true if @children_only
         locator
       end
     end
   end
-end
+end

data/lib/mohawk/version.rb

@@ -1,3 +1,3 @@
 module Mohawk
-  VERSION = "0.1.4"
+  VERSION = "0.2"
 end

data/lib/mohawk/waiter.rb

@@ -0,0 +1,18 @@
+module Mohawk
+  module Waiter
+    extend self
+
+    class WaitTimeout < StandardError;
+    end
+
+    def wait_until(timeout=Mohawk.timeout, &block)
+      start = Time.now
+      until (result = block.call) || (Time.now - start > timeout)
+        sleep 0.25
+      end
+
+      raise WaitTimeout unless result
+      result
+    end
+  end
+end

data/lib/mohawk/win_32.rb

@@ -0,0 +1,12 @@
+require 'ffi'
+
+module Mohawk
+  module Win32
+    extend FFI::Library
+    ffi_lib 'user32.dll'
+    attach_function :set_foreground_window, :SetForegroundWindow, [:long], :bool
+    attach_function :foreground_window, :GetForegroundWindow, [], :int
+    attach_function :is_window, :IsWindow, [:int], :bool
+    attach_function :activate, :SetActiveWindow, [:int], :int
+  end
+end

data/lib/mohawk.rb

@@ -1,17 +1,16 @@
-require "rautomation"
 require 'childprocess'
-require "mohawk/version"
-require "require_all"
-require "mohawk/accessors"
-require "mohawk/navigation"
-require "mohawk/adapters/uia_adapter"
-require "mohawk/core_ext/string"
+require 'mohawk/version'
+require 'require_all'
+require 'mohawk/accessors'
+require 'mohawk/navigation'
+require 'mohawk/adapters/uia_adapter'
+require 'mohawk/core_ext/string'
 
-require_rel "mohawk/accessors"
+require_rel 'mohawk/accessors'
 
 module Mohawk
-  include RAutomation::WaitHelper
-  extend RAutomation::WaitHelper
+  include Waiter
+  extend Waiter
 
   class InvalidApplicationPath < StandardError
     def initialize(message='You must set the Mohawk.app_path to start an application')
@@ -29,8 +28,7 @@ module Mohawk
     raise InvalidApplicationPath.new unless @app_path
     @app = ChildProcess.build(@app_path).start
 
-    app_window = RAutomation::Window.new :pid => @app.pid
-    wait_until { app_window.present? }
+    wait_until { Uia.find_element pid: @app.pid  }
   end
 
   def self.stop
@@ -47,10 +45,24 @@ module Mohawk
     @app_path = path
   end
 
+  class << self
+    attr_accessor :timeout
+    attr_accessor :default_adapter
+  end
+  self.timeout = 60
+
+  def self.default_adapter
+    @default_adapter || Mohawk::Adapters::UiaAdapter
+  end
+
+  def self.default_adapter=(cls)
+    @default_adapter = cls
+  end
+
   def initialize(extra={})
     locator = [which_window.merge(extra)]
     locator << parent_container if respond_to?(:parent_container)
-    @adapter = Mohawk::Adapters::UiaAdapter.new(*locator)
+    @adapter = Mohawk.default_adapter.new(*locator)
   end
 
   #
@@ -85,7 +97,7 @@ module Mohawk
   # Waits until a control exists
   #
   def wait_for_control(locator)
-    control = adapter.window.control(locator)
+    control = adapter.control(locator)
     begin
       wait_until { control.exist? }
     rescue

data/mohawk.gemspec

@@ -18,14 +18,14 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'rautomation', '~> 0.14'
+  gem.add_dependency 'uia', '>= 0.3.1'
   gem.add_dependency 'require_all'
   gem.add_dependency 'page_navigation', '>= 0.7'
   gem.add_dependency 'childprocess', '~> 0.3.9'
-  gem.add_dependency 'ffi', '1.9.0'
 
   gem.add_development_dependency 'cucumber'
   gem.add_development_dependency 'rspec', '>= 2.12.0'
+  gem.add_development_dependency 'rspec-given'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'childprocess'
   gem.add_development_dependency 'rb-fsevent', '~> 0.9.1'

data/spec/lib/mohawk/adapters/uia/control_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Mohawk::Adapters::UiaAdapter::Control do
+  let(:adapter) { double(window: window) }
+  let(:window) { double(element: parent) }
+  let(:parent) { double(find: element) }
+  let(:element) { double('uia element') }
+
+  def new_control(locator)
+    Mohawk::Adapters::UiaAdapter::Control.new adapter, locator
+  end
+
+  Given(:control) { new_control(id: 'whatever') }
+
+  context 'working with the element directly' do
+    context 'passes through if it can' do
+      When { expect(element).to receive(:bounding_rectangle).and_return [1, 2, 3, 4] }
+      Then { expect(control.bounding_rectangle).to eq [1, 2, 3, 4] }
+    end
+
+    context 'fails otherwise' do
+      When(:bad_method) { control.does_not_have }
+      Then { expect(bad_method).to have_failed NoMethodError }
+    end
+  end
+
+  class HasPattern < Mohawk::Adapters::UiaAdapter::Control
+    valid_patterns :this, :that
+  end
+
+  context '#patterns' do
+    Given { parent.stub(:find) {|l| @locator = l } }
+    Given(:no_filter) { new_control(id: 'hi') }
+    Given(:some_filter) { HasPattern.new adapter, id: 'hi' }
+    Given(:overridden) { HasPattern.new adapter, id: 'hi', pattern: :overridden }
+
+    def pattern(control)
+      control.exist?
+      @locator.delete(:pattern)
+    end
+
+    Then { pattern(no_filter) == nil }
+    Then { pattern(some_filter) == [:this, :that] }
+    Then { pattern(overridden) == :overridden }
+  end
+end

data/spec/lib/mohawk/adapters/uia/table_row_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Mohawk::Adapters::UIA::TableRow do
+  let(:table) { double 'table', element: table_element }
+  let(:table_element) { double 'table element', row_at: element }
+  let(:element) { double 'row Element' }
+
+  subject { Mohawk::Adapters::UIA::TableRow.new table, 123 }
+
+  def set_expected_cells(h)
+    element.stub(:items).and_return h.values.map {|v| UiaTableCell.new v }
+    table.stub(:headers).and_return h.keys.map(&:to_s)
+  end
+
+  context '#all_match?' do
+    it 'matches string values' do
+      set_expected_cells 'First Column' => 'Yo'
+
+      expect(subject).to be_all_match first_column: 'Yo'
+    end
+
+    it 'matches non-string values' do
+      set_expected_cells 'Date Field' => Date.today.to_s
+
+      expect(subject).to be_all_match date_field: Date.today
+    end
+  end
+
+  class UiaTableCell
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+end

data/spec/lib/mohawk/waiter_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class WaiterStub
+  include Mohawk::Waiter
+end
+
+describe Mohawk::Waiter do
+  Given(:waiter) do
+    allow_any_instance_of(WaiterStub).to receive(:sleep) {}
+    WaiterStub.new
+  end
+
+  def fake_time(*times)
+    expect(Time).to receive(:now).exactly(times.count).times.and_return(*times)
+  end
+
+  def do_it
+    @fake_responses.shift
+  end
+
+  context 'default timeout' do
+    When { fake_time 0, 30, 60.1 }
+    Then { expect { waiter.wait_until { false } }.to raise_error Mohawk::WaitTimeout }
+  end
+
+  context 'specific timeout' do
+    When { fake_time 0, 30, 30.1 }
+    Then { expect { waiter.wait_until(30) { false } }.to raise_error Mohawk::WaitTimeout }
+  end
+
+  context 'waits in between' do
+    When do
+      @fake_responses = [false,  true]
+      fake_time 0, 1
+    end
+
+    Then { expect { waiter.wait_until { do_it } }.not_to raise_error }
+  end
+end