rautomation 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.idea/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jarmo Pertman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,71 @@
+= RAutomation
+
+* Web: http://www.github.com/jarmo/RAutomation
+* Author: Jarmo Pertman (mailto:jarmo.p[at]gmail.com)
+
+== DESCRIPTION
+
+RAutomation tries to be a small and easy to use library for helping out to automate windows and their controls
+for automated testing.
+
+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>!
+
+== USAGE
+
+    require "rautomation"
+
+    window = RAutomation::Window.new(:title => /part of the title/i)
+    window.exists? # => true
+
+    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!"
+    button = window.button(:text => "&Save")
+    button.exists? # => true
+    button.click
+
+See more examples in spec directory!
+
+== INSTALL
+
+=== Windows
+
+1. gem install rautomation
+2. create some script and run it
+
+You might need administrative privileges if running for the first time and you haven't installed AutoIt before!
+
+=== Linux
+
+Feel yourself at home on Linux and know how to automate windows and their controls? I would be happy if you'd contact me
+about that matter - or even better, send me a pull request!
+
+=== OS X
+
+Feel yourself at home on OS X and know how to automate windows and their controls? I would be happy if you'd contact me
+about that matter - or even better, send me a pull request!
+
+=== Others
+
+Feel yourself at home on some operating system not listed in here and know how to automate windows and their controls?
+Does Ruby also work on that operating system? I would be happy if you'd contact me
+about that matter - or even better, send me a pull request!
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Jarmo Pertman. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rautomation"
+    gem.summary = %Q{Automate windows and their controls through user-friendly API with Ruby}
+    gem.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.
+
+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!}
+    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"
+  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
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "RAutomation #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/rautomation.rb

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

data/lib/rautomation/button.rb

@@ -0,0 +1,39 @@
+module RAutomation
+  class Button
+    # This constructor is meant to be accessed only through RAutomation::Window#button method.
+    def initialize(window, locators) #:nodoc:
+      @window = window
+      @locators = locators
+      @button = @window.button(@locators)
+    end
+
+    # Performs a click on the Button.
+    #
+    # Raises an UnknownButtonException if the Button itself doesn't exist.
+    def click
+      assert_exists
+      @button.click
+    end
+
+    # Retrieves the value of the Button, usually the visible text.
+    #
+    # Raises an UnknownButtonException if the Button itself doesn't exist.
+    def value
+      assert_exists
+      @button.value
+    end
+
+    # Returns true if Button exists, false otherwise.
+    def exists?
+      @button.exists?
+    end
+
+    alias_method :exist?, :exists?
+
+    private
+
+    def assert_exists
+      raise UnknownButtonException.new("Button '#{@locators.inspect}' doesn't exist on window '#{@window.locators.inspect}'!") unless exists?
+    end
+  end
+end

data/lib/rautomation/implementations/autoit.rb

@@ -0,0 +1,5 @@
+require "win32ole"
+require File.dirname(__FILE__) + "/autoit/locators"
+require File.dirname(__FILE__) + "/autoit/window"
+require File.dirname(__FILE__) + "/autoit/button"
+require File.dirname(__FILE__) + "/autoit/text_field"

data/lib/rautomation/implementations/autoit/button.rb

@@ -0,0 +1,40 @@
+module RAutomation
+  module Implementations
+    module AutoIt
+      class Button
+        include WaitHelper
+        include Locators
+
+        # Special-cased locators
+        LOCATORS = {:class_name => :classnn}
+
+        # Possible locators are :text, :id, :class, :class_name and :instance.
+        def initialize(window, locators)
+          @window = window
+          extract(locators)
+        end
+
+        def click #:nodoc:
+          clicked = false
+          wait_until do
+            @window.activate
+            @window.active? &&
+                    Window.autoit.ControlFocus(@window.locator_hwnd, "", @locators) == 1 &&
+                    Window.autoit.ControlClick(@window.locator_hwnd, "", @locators) == 1 &&
+                    clicked = true # is clicked at least once
+
+            clicked && !exists?
+          end
+        end
+
+        def value #:nodoc:
+          Window.autoit.ControlGetText(@window.locator_hwnd, "", @locators)
+        end
+
+        def exists? #:nodoc:
+          not Window.autoit.ControlGetHandle(@window.locator_hwnd, "", @locators).empty?
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/implementations/autoit/locators.rb

@@ -0,0 +1,18 @@
+module RAutomation
+  module Implementations
+    module AutoIt
+      module Locators
+
+        private
+
+        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_s(16) if locator == :hwnd
+            "#{(locator_key || locator)}:#{value}"
+          end.join(";")}]"
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/implementations/autoit/text_field.rb

@@ -0,0 +1,41 @@
+module RAutomation
+  module Implementations
+    module AutoIt
+      class TextField
+        include WaitHelper
+        include Locators
+
+        # Special-cased locators
+        LOCATORS = {:class_name => :classnn}
+
+        # Possible locators are :id, :class, :class_name and :instance.
+        def initialize(window, locators)
+          @window = window
+          extract(locators)
+        end
+
+        def set(text) #:nodoc:
+          wait_until do
+            @window.activate
+            @window.active? &&
+                    Window.autoit.ControlFocus(@window.locator_hwnd, "", @locators) == 1 &&
+                    Window.autoit.ControlSetText(@window.locator_hwnd, "", @locators, text) == 1 &&
+                    value == text
+          end
+        end
+
+        def clear #:nodoc:
+          set ""
+        end
+
+        def value #:nodoc:
+          Window.autoit.ControlGetText(@window.locator_hwnd, "", @locators)
+        end
+
+        def exists? #:nodoc:
+          not Window.autoit.ControlGetHandle(@window.locator_hwnd, "", @locators).empty?
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/implementations/autoit/window.rb

@@ -0,0 +1,126 @@
+module RAutomation
+  module Implementations
+    module AutoIt
+      class Window
+        include WaitHelper
+        include Locators
+
+        class << self
+          def autoit #:nodoc:
+            @@autoit
+          end
+
+          def load_autoit #:nodoc:
+            @@autoit = WIN32OLE.new('AutoItX3.Control')
+          rescue WIN32OLERuntimeError
+            dll = File.dirname(__FILE__) + "/../../../ext/AutoItX/AutoItX3.dll"
+            system("regsvr32.exe /s #{dll.gsub('/', '\\')}")
+            @@autoit = WIN32OLE.new('AutoItX3.Control')
+          end
+        end
+
+        load_autoit
+        @@autoit.AutoItSetOption("WinWaitDelay", 350)
+
+        attr_reader :locators
+
+        # Special-cased locators
+        LOCATORS = {[:title, String] => :title,
+                    [:title, Regexp] => :regexptitle,
+                    :hwnd => :handle}
+
+        # Possible locators are :title, :text, :hwnd and :class.
+        def initialize(locators)
+          @hwnd = locators[:hwnd]
+          @locator_text = locators.delete(:text)
+          extract(locators)
+        end
+
+        def hwnd #:nodoc:
+          @hwnd ||= @@autoit.WinList(@locators, @locator_text).pop.compact.
+                  find {|handle| self.class.new(:hwnd => handle.hex).visible?}.hex rescue nil
+        end
+
+        def title #:nodoc:
+          @@autoit.WinGetTitle(locator_hwnd)
+        end
+
+        def activate #:nodoc:
+          @@autoit.WinWait(locator_hwnd, "", 1)
+          @@autoit.WinActivate(locator_hwnd)
+          sleep 1
+        end
+
+        def active? #:nodoc:
+          @@autoit.WinActive(locator_hwnd) == 1
+        end
+
+        def text #:nodoc:
+          @@autoit.WinGetText(locator_hwnd)
+        end
+
+        def exists? #:nodoc:
+          @@autoit.WinExists(locator_hwnd) == 1
+        end
+
+        def visible? #:nodoc:
+          @@autoit.WinGetState(locator_hwnd) & 2 == 2
+        end
+
+        def maximize #:nodoc:
+          @@autoit.WinSetState(locator_hwnd, "", @@autoit.SW_MAXIMIZE)
+          sleep 1
+        end
+
+        def minimize #:nodoc:
+          @@autoit.WinSetState(locator_hwnd, "", @@autoit.SW_MINIMIZE)
+          sleep 1
+        end
+
+        def minimized?
+          @@autoit.WinGetState(locator_hwnd) & 16 == 16
+        end
+
+        def restore
+          @@autoit.WinSetState(locator_hwnd, "", @@autoit.SW_RESTORE)
+          sleep 1
+        end
+
+        # Activates the Window and sends keys to it.
+        #
+        # Refer to AutoIt documentation for keys syntax.
+        def send_keys(keys)
+          wait_until do
+            restore if minimized?
+            activate
+            active?
+          end
+          @@autoit.Send(keys)
+        end
+
+        def close #:nodoc:
+          @@autoit.WinClose(locator_hwnd)
+          @@autoit.WinKill(locator_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:
+          @@autoit.respond_to?(name) ? @@autoit.send(name, *args) : super
+        end
+
+        # Used internally.
+        # @private
+        def locator_hwnd
+          "[HANDLE:#{hwnd.to_i.to_s(16)}]"
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/implementations/helper.rb

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

data/lib/rautomation/text_field.rb

@@ -0,0 +1,47 @@
+module RAutomation
+  class TextField
+    # This constructor is meant to be accessed only through RAutomation::Window#text_field method.
+    def initialize(window, locators) #:nodoc:
+      @window = window
+      @locators = locators
+      @text_field = @window.text_field(@locators)
+    end
+
+    # Sets TextField's text to +text+.
+    #
+    # Raises an UnknownTextFieldException if the TextField itself doesn't exist.
+    def set(text)
+      assert_exists
+      @text_field.set(text)
+    end
+
+    # Clears TextField's text.
+    #
+    # Raises an UnknownTextFieldException if the TextField itself doesn't exist.
+    def clear
+      assert_exists
+      @text_field.clear
+    end
+
+    # Returns TextField's text.
+    #
+    # Raises an UnknownTextFieldException if the TextField itself doesn't exist.
+    def value
+      assert_exists
+      @text_field.value
+    end
+
+    # Returns true if TextField exists, false otherwise.
+    def exists?
+      @text_field.exists?
+    end
+
+    alias_method :exist?, :exists?
+
+    private
+
+    def assert_exists
+      raise UnknownTextFieldException.new("Text field '#{@locators.inspect}' doesn't exist on window '#{@window.locators.inspect}'!") unless exists?
+    end
+  end
+end

data/lib/rautomation/wait_helper.rb

@@ -0,0 +1,23 @@
+module RAutomation
+  module WaitHelper
+    extend self
+    
+    class TimeoutError < StandardError
+    end
+
+    #
+    # Wait until the block evaluates to true or times out.
+    #
+    def wait_until(timeout = 60, &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

data/lib/rautomation/window.rb

@@ -0,0 +1,176 @@
+module RAutomation
+  class UnknownWindowException < RuntimeError
+  end
+  class UnknownButtonException < RuntimeError
+  end
+  class UnknownTextFieldException < RuntimeError
+  end
+
+  class Window
+    include Implementations::Helper
+
+    attr_reader :implementation
+
+    # Creates a new Window object using the _locators_ Hash parameter.
+    #
+    # Possible Window _locators_ may depend of the used platform and implementation, but
+    # following examples will use :title, :class and :hwnd.
+    #
+    # Use window with _some title_ being part of it's title:
+    #   RAutomation::Window.new(:title => "some title")
+    #
+    # Use window with Regexp title:
+    #   RAutomation::Window.new(:title => /some title/i)
+    #
+    # Use window with handle _123456_:
+    #   RAutomation::Window.new(:hwnd => 123456)
+    #
+    # 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.
+    #
+    # _locators_ may also include a key called :implementation to change default implementation,
+    # 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>
+    #
+    # * 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)
+    end
+
+    # Returns handle of the Window.
+    #
+    # This handle will be used internally for all operations.
+    def hwnd
+      assert_exists
+      @window.hwnd
+    end
+
+    # Returns title of the Window.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def title
+      assert_exists
+      @window.title
+    end
+
+    # Activates the Window, e.g. brings to the top.
+    def activate
+      @window.activate
+    end
+
+    # Returns true if the Window is active, false otherwise.
+    def active?
+      @window.active?
+    end
+
+    # Returns visible text of the Window.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def text
+      assert_exists
+      @window.text
+    end
+
+    # Returns true if the Window exists, false otherwise.
+    def exists?
+      @window.exists?
+    end
+
+    alias_method :exist?, :exists?
+
+    # Returns true if the Window is visible, false otherwise.
+    # Window is also visible, if it is behind other windows or minimized.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def visible?
+      assert_exists
+      @window.visible?
+    end
+
+    # Returns true if the Window exists and is visible, false otherwise.
+    def present?
+      exists? && visible?
+    end
+
+    # Maximizes the Window.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def maximize
+      assert_exists
+      @window.maximize
+    end
+
+    # Minimizes the Window.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def minimize
+      assert_exists
+      @window.minimize
+    end
+
+    # Returns true if the Window is minimized, false otherwise.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def minimized?
+      assert_exists
+      @window.minimized?
+    end
+
+    # Restores the Window.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def restore
+      assert_exists
+      @window.restore
+    end
+
+    # Sends keys to the Window. Refer to specific implementation's documentation for possible values.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def send_keys(keys)
+      assert_exists
+      @window.send_keys(keys)
+    end
+
+    # Closes the Window if it exists.
+    def close
+      return unless @window.exists?
+      @window.close
+    end
+
+    # Returns the Button object by the _locators_ on the Window.
+    # Refer to specific implementation's documentation for possible parameters.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def button(locators)
+      assert_exists
+      Button.new(@window, locators)
+    end
+
+    # Returns the TextField object by the _locators_ on the Window.
+    # Refer to specific implementation's documentation for possible parameters.
+    #
+    # Raises an UnknownWindowException if the Window itself doesn't exist.
+    def text_field(locators)
+      assert_exists
+      TextField.new(@window, locators)
+    end
+
+    # Allow to execute implementation's methods not part of the public API
+    def method_missing(name, *args)
+      @window.respond_to?(name) ? @window.send(name, *args) : super
+    end
+
+    private
+
+    def assert_exists
+      raise UnknownWindowException.new("Window with locator '#{@window.locators.inspect}' doesn't exist!") unless exists?
+    end
+  end
+end

data/rautomation.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rautomation}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jarmo Pertman"]
+  s.date = %q{2010-10-13}
+  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.
+
+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!}
+  s.email = %q{jarmo.p@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "ext/AutoItX/AutoItX.chm",
+     "ext/AutoItX/AutoItX3.dll",
+     "lib/rautomation.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",
+     "spec/window_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/jarmo/RAutomation}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Automate windows and their controls through user-friendly API with Ruby}
+  s.test_files = [
+    "spec/button_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/text_field_spec.rb",
+     "spec/window_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    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"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.3.0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.3.0"])
+  end
+end
+

data/spec/button_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe RAutomation::Button do
+  it "#button" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).
+            button(:text => SpecHelper::DATA[:window2_button_text]).should exist
+    lambda {RAutomation::Window.new(:title => "non-existing-window").button(:text => "Something")}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#value" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).
+            button(:text => SpecHelper::DATA[:window2_button_text]).value.should == SpecHelper::DATA[:window2_button_text]
+    lambda {RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).button(:text => "non-existent-button").value}.
+            should raise_exception(RAutomation::UnknownButtonException)
+  end
+
+  it "#exists?" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
+    window.button(:text => SpecHelper::DATA[:window2_button_text]).should exist
+    window.button(:text => "non-existent-button").should_not exist
+  end
+
+  it "#click" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
+    lambda{window.button(:text => "non-existent-button").click}.
+            should raise_exception(RAutomation::UnknownButtonException)
+
+    button = window.button(:text => SpecHelper::DATA[:window2_button_text])
+    button.should exist
+    button.click
+    button.should_not exist
+    window.should_not exist
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rautomation'
+require 'spec'
+require 'spec/autorun'
+
+module SpecHelper
+  # Since implementations 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.
+  #
+  # 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" => {
+                  # 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.
+                  :window2_send_keys => "{ENTER}",
+                  # 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"
+          }
+  }[ENV["RAUTOMATION_IMPLEMENTATION"] || RAutomation::Implementations::Helper.default_implementation.to_s]
+end
+
+Spec::Runner.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
+    window1 = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    RAutomation::WaitHelper.wait_until(15) {window1.present?}
+    window2 = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title])
+    RAutomation::WaitHelper.wait_until(15) {window2.present?}
+  end
+
+  config.after(:all) do
+    Process.kill(9, @pid1) rescue nil
+    Process.kill(9, @pid2) rescue nil
+  end
+end

data/spec/test.html

@@ -0,0 +1,13 @@
+<html>
+<head>
+    <title>RAutomation testing page</title>
+    <script type="text/javascript">
+        function showPrompt() {
+            prompt("Where do you want to go today?");
+        }
+    </script>
+</head>
+<body onload="setTimeout(showPrompt, 1000)">
+<h1>RAutomation testing page</h1>
+</body>
+</html>

data/spec/text_field_spec.rb

@@ -0,0 +1,47 @@
+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
+    lambda {RAutomation::Window.new(:title => "non-existent-window").
+            text_field(:class_name => SpecHelper::DATA[:window2_text_field_class_name])}.
+            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!"
+    lambda {window.text_field(:class_name => "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.set "hello!"
+    field.value.should == "hello!"
+    field.clear
+    field.value.should be_empty
+
+    lambda {window.text_field(:class_name => "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.set "hello!"
+    field.value.should == "hello!"
+
+    lambda {window.text_field(:class_name => "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.should exist
+    window.text_field(:class_name => "non-existent-field").should_not exist
+  end
+end

data/spec/window_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe RAutomation::Window do
+  it "RAutomation::Window.implementation" do
+    RAutomation::Window.new(:title => "random").implementation.should == (ENV["RAUTOMATION_IMPLEMENTATION"] || RAutomation::Implementations::Helper.default_implementation)
+  end
+
+  it "Window#new by full title" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).should exist
+  end
+
+  it "Window#new by regexp title" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).should exist
+  end
+
+  it "Window#new by hwnd" do
+    hwnd = RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).hwnd
+    window = RAutomation::Window.new(:hwnd => hwnd)
+    window.should exist
+    window.title.should == SpecHelper::DATA[:window2_title]
+  end
+
+  it "#exists?" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).should exist
+    RAutomation::Window.new(:title => "non-existing-window").should_not exist
+  end
+
+  it "#visible?"do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).should be_visible
+    lambda{RAutomation::Window.new(:title => "non-existing-window").visible?}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#present?"do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).should be_present
+    RAutomation::Window.new(:title => "non-existing-window").should_not be_present
+  end
+
+  it "#hwnd" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).hwnd.should be_a(Fixnum)
+    lambda {RAutomation::Window.new(:title => "non-existing-window").hwnd}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#title" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).title.should == SpecHelper::DATA[:window2_title]
+    lambda {RAutomation::Window.new(:title => "non-existing-window").title}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#activate & #active?" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    window.activate
+    window.should be_active
+    non_existing_window = RAutomation::Window.new(:title => "non-existing-window")
+    non_existing_window.activate
+    non_existing_window.should_not be_active
+  end
+
+  it "#text" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window2_title]).text.should include(SpecHelper::DATA[:window2_text])
+    lambda {RAutomation::Window.new(:title => "non-existing-window").text}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#maximize" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).maximize
+    lambda {RAutomation::Window.new(:title => "non-existing-window").maximize}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#minimize && #minimized?" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    window.should_not be_minimized
+    window.minimize
+    window.should be_minimized
+
+    lambda {RAutomation::Window.new(:title => "non-existing-window").minimize}.
+            should raise_exception(RAutomation::UnknownWindowException)
+    lambda {RAutomation::Window.new(:title => "non-existing-window").minimized?}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#restore" do
+    RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).restore
+    lambda {RAutomation::Window.new(:title => "non-existing-window").restore}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  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
+    window.send_keys(SpecHelper::DATA[:window2_send_keys])
+    RAutomation::WaitHelper.wait_until(15) {not window.exists?}
+
+    lambda {RAutomation::Window.new(:title => "non-existing-window").send_keys("123")}.
+            should raise_exception(RAutomation::UnknownWindowException)
+  end
+
+  it "#close" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    window.should exist
+    window.close
+    window.should_not exist
+
+    lambda {RAutomation::Window.new(:title => "non-existing-window").close}.
+            should_not raise_exception
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: rautomation
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jarmo Pertman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-13 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
+description: |-
+  RAutomation tries to be a small and easy to use library for helping out to automate windows and their controls
+  for automated testing.
+  
+  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!
+email: jarmo.p@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- ext/AutoItX/AutoItX.chm
+- ext/AutoItX/AutoItX3.dll
+- lib/rautomation.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
+- spec/window_spec.rb
+has_rdoc: true
+homepage: http://github.com/jarmo/RAutomation
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Automate windows and their controls through user-friendly API with Ruby
+test_files: 
+- spec/button_spec.rb
+- spec/spec_helper.rb
+- spec/text_field_spec.rb
+- spec/window_spec.rb