win32-autogui 0.2.0

data/lib/win32/autogui/window.rb

@@ -0,0 +1,191 @@
+require 'windows/window'
+require 'windows/window/message'
+require 'win32/autogui/windows/window'
+
+module Autogui
+
+  # Enumerate desktop child windows
+  #
+  # Start at the desktop and work down through all the child windows
+  #
+  class EnumerateDesktopWindows
+    include Enumerable
+    include Windows::Window
+
+    def each
+      child_after = 0
+      while (child_after = FindWindowEx(nil, child_after, nil, nil)) > 0 do
+        yield Window.new child_after
+      end
+    end
+  end
+
+  # Enumerate just the child windows one level down from the parent window
+  #
+  class Children
+    include Enumerable
+    include Windows::Window
+
+    # @param [Number] parent window handle
+    #
+    def initialize(parent)
+      @parent = parent
+    end
+
+    # @yield [Window]
+    #
+    def each
+      child_after = 0
+      while (child_after = FindWindowEx(@parent.handle, child_after, nil, nil)) > 0 do
+        window = Window.new child_after
+        # immediate children only
+        yield window if (window.parent.handle == @parent.handle)
+      end
+    end
+  end
+
+  # Wrapper for window
+  #
+  class Window
+    include Windows::Window           # instance methods from windows-pr gem
+    include Windows::Window::Message  # PostMessage and constants
+
+    attr_reader :handle
+
+    def initialize(handle)
+      @handle = handle
+    end
+    
+    # enumerable immeadiate child windows
+    #
+    # @see Children
+    #
+    def children
+      Children.new(self)
+    end
+
+    # @return [Object] Window or nil 
+    #
+    def parent
+      h = GetParent(handle)
+      Window.new h if h > 0
+    end
+
+    # PostMessage SC_CLOSE and optionally wait for the window to close
+    #
+    # @param [Hash] options
+    # @option options [Boolean] :wait_for_close (true) sleep while waiting for timeout or close
+    # @option options [Boolean] :timeout (5) wait_for_close timeout in seconds
+    #
+    def close(options={})
+      PostMessage(handle, WM_SYSCOMMAND, SC_CLOSE, 0)
+      wait_for_close(options) if (options[:wait_for_close] == true) 
+    end
+    
+    # Wait for the window to close
+    #
+    # @param [Hash] options
+    # @option options [Boolean] :timeout (5) timeout in seconds
+    #
+    def wait_for_close(options={})
+      seconds = options[:timeout] || 5
+      timeout(seconds) do
+        sleep 0.05 until 0 == IsWindow(handle)
+      end
+    end
+
+    # @return [String] the ANSI Windows ClassName
+    # 
+    def window_class
+      buffer = "\0" * 255
+      length = GetClassNameA(handle, buffer, buffer.length)
+      length == 0 ? '' : buffer[0..length - 1]
+    end
+
+    # Window text (WM_GETTEXT)
+    #
+    # @param [Number] max_length (2048)
+    #
+    # @return [String] of max_length (2048)
+    #
+    def text(max_length = 2048)
+      buffer = "\0" * max_length
+      length = SendMessageA(handle, WM_GETTEXT, buffer.length, buffer)
+      length == 0 ? '' : buffer[0..length - 1]
+    end
+    alias :title :text
+
+    # Determines whether the specified window handle identifies an existing window 
+    #
+    # @return [Boolean]
+    #
+    def is_window?
+      (handle != 0) && (IsWindow(handle) != 0)
+    end
+    
+    # Brings the window into the foreground and activates it. 
+    # Keyboard input is directed to the window, and various visual cues 
+    # are changed for the user.
+    #
+    # @return [Number] nonzero number if sucessful, nil or zero if failed
+    #
+    def set_focus
+      SetForegroundWindow(handle) if is_window?
+    end
+
+    # The identifier (pid) of the process that created the window
+    #
+    # @return [Integer] process id if the window exists, otherwise nil
+    #
+    def pid
+      return nil unless is_window?
+      process_id = 0.chr * 4
+      GetWindowThreadProcessId(handle, process_id)
+      process_id = process_id.unpack('L').first
+    end
+
+    # The identifier of the thread that created the window
+    #
+    # @return [Integer] thread id if the window exists, otherwise nil
+    #
+    def thread_id
+      return nil unless is_window?
+      GetWindowThreadProcessId(handle, nil)
+    end
+
+    # The window text including all child windows 
+    # joined together with newlines. Faciliates matching text.
+    # Text from any given window is limited to 2048 characters
+    #
+    # @example partial match of the Window's calulator's about dialog copywrite text
+    #
+    #   dialog_about = @calculator.dialog_about
+    #   dialog_about.title.should == "About Calculator"
+    #   dialog_about.combined_text.should match(/Microsoft . Calculator/)
+    #
+    # @return [String] with newlines
+    #
+    def combined_text
+      return unless is_window?
+      t = []
+      t << text unless text == ''
+      children.each do |w| 
+        t << w.combined_text unless w.combined_text == ''
+      end
+      t.join("\n")
+    end
+
+    # Debugging information
+    #
+    # @return [String] with child window information
+    def inspect
+      c = [] 
+      children.each do |w| 
+        c << w.inspect 
+      end
+      s = super + " #{self.class}=<window_class:#{window_class} pid:#{pid} thread_id:#{thread_id} title:\"#{title}\" children=<" + c.join("\n") + ">>"
+    end
+
+  end
+
+end

data/lib/win32/autogui/windows/window.rb

@@ -0,0 +1,22 @@
+# Reopen module and supply missing constants and 
+# functions from windows-pr gem
+#
+# TODO: Fork and send pull request for Windows::Window module, be sure to lock bundle before sending request
+#
+module Windows
+  module Window
+
+    SC_CLOSE = 0xF060
+
+    API.auto_namespace = 'Windows::Window'
+    API.auto_constant  = true
+    API.auto_method    = true
+    API.auto_unicode   = false
+
+    API.new('IsWindow', 'L', 'I', 'user32')
+    API.new('SetForegroundWindow', 'L', 'I', 'user32')
+    API.new('SendMessageA', 'LIIP', 'I', 'user32')
+    API.new('GetClassNameA', 'LPI', 'I', 'user32')
+
+  end
+end

data/spec/applications/calculator.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class Calculator < Autogui::Application
+
+  # initialize with the binary name 'calc' and the window title
+  # 'Calculator' used along with the application pid to find the 
+  # main application window
+  def initialize(options = {})
+    defaults = {
+                 :name => "calc",
+                 :title => "Calculator"
+               }
+    super defaults.merge(options)
+  end
+
+  # the calculator's results window 
+  def edit_window
+    main_window.children.find {|w| w.window_class == 'Edit'}
+  end
+
+  # About dialog, hotkey (VK_MENU, VK_H, VK_A)
+  def dialog_about
+    Autogui::EnumerateDesktopWindows.new.find do |w| 
+      w.title.match(/About Calculator/) && (w.pid == pid)
+    end
+  end
+
+  # the 'CE' button
+  def clear_entry
+    set_focus
+    keystroke(VK_DELETE)
+  end
+
+end

data/spec/auto_gui/application_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Autogui::Input
+
+describe Autogui::Application do
+
+  describe "driving calc.exe" do
+
+    before(:all) do
+      @calculator = Calculator.new
+      @calculator.set_focus
+    end
+
+    after(:all) do
+      @calculator.close(:wait_for_close => true) if @calculator.running?
+      @calculator.should_not be_running
+    end
+
+    it "should start when initialized" do
+      @calculator.should be_running
+    end
+
+    it "should die when sending the kill signal" do
+      killme = Calculator.new
+      killme.should be_running
+      killme.kill
+      killme.should_not be_running
+    end
+
+    it "should have the title 'Calculator' that matches the main_window title" do
+      @calculator.main_window.title.should == 'Calculator'
+      @calculator.main_window.title.should == @calculator.title
+    end
+
+    it "should have an inspect method showing child window information" do
+      @calculator.inspect.should match(/children=</)
+    end
+
+    it "should raise an error if setting focus and the application title is incorrect" do
+      goodcalc = Calculator.new :title => "Calculator"
+      lambda { goodcalc.set_focus }.should_not raise_error
+      goodcalc.close
+
+      badcalc = Calculator.new :title => "BaDTitle"
+      lambda {
+        begin
+          badcalc.setfocus
+        ensure
+          badcalc.kill
+        end
+      }.should raise_error
+    end
+
+    it "should control the focus with 'set_focus'" do
+      @calculator.set_focus
+      keystroke(VK_9)
+      @calculator.edit_window.text.strip.should == "9."
+      
+      calculator2 = Calculator.new
+      calculator2.pid.should_not == @calculator.pid
+      calculator2.set_focus
+      keystroke(VK_1, VK_0) 
+      calculator2.edit_window.text.strip.should == "10."
+
+      @calculator.set_focus
+      @calculator.edit_window.text.strip.should == "9."
+
+      calculator2.close(:wait_for_close => true)
+    end
+
+    it "should open and close the 'About Calculator' dialog via (VK_MENU, VK_H, VK_A)" do
+      @calculator.set_focus
+      dialog_about = @calculator.dialog_about
+      dialog_about.should be_nil
+      keystroke(VK_MENU, VK_H, VK_A) 
+      dialog_about = @calculator.dialog_about
+      dialog_about.title.should == "About Calculator"
+      dialog_about.combined_text.should match(/Microsoft . Calculator/)
+      dialog_about.close
+      @calculator.dialog_about.should be_nil
+    end
+
+    describe "calculations" do
+      before(:each) do
+        @calculator.clear_entry
+      end
+
+      it "should calculate '2+2=4' using the keystroke method" do
+        @calculator.set_focus
+        keystroke(VK_2, VK_ADD, VK_2, VK_RETURN) 
+        @calculator.edit_window.text.strip.should == "4."
+      end
+
+      it "should calculate '2+12=14' using the type_in method" do
+        @calculator.set_focus
+        type_in("2+12=")
+        @calculator.edit_window.text.strip.should == "14."
+      end
+    end
+
+    describe "clipboard" do
+      before(:each) do
+        @calculator.clear_entry
+        @calculator.clipboard.text = ""
+        @calculator.clipboard.text.should == ""
+      end
+      
+      describe "copy (VK_CONTROL, VK_C)" do
+        it "should copy the edit window" do
+          @calculator.set_focus
+          type_in("3002")
+          @calculator.edit_window.text.strip.should == "3,002."
+          @calculator.edit_window.set_focus
+          keystroke(VK_CONTROL, VK_C) 
+          @calculator.clipboard.text.should == "3002"
+        end
+      end
+
+      describe "paste (VK_CONTROL, VK_V)" do
+        it "should paste into the edit window" do
+          @calculator.edit_window.set_focus
+          @calculator.clipboard.text = "12345"
+          @calculator.edit_window.text.strip.should == "0."
+          keystroke(VK_CONTROL, VK_V) 
+          @calculator.edit_window.text.strip.should == "12,345."
+        end
+      end
+
+    end
+
+  end
+end

data/spec/basic_gem/basic_gem_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Autogui do
+  
+  describe 'version' do
+
+    it "should return a string formatted '#.#.#'" do
+      Autogui::version.should match(/(^[\d]+\.[\d]+\.[\d]+$)/)
+    end
+
+  end
+
+end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift File.expand_path('..', __FILE__) unless
+  $LOAD_PATH.include? File.expand_path('..', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__) unless
+  $LOAD_PATH.include? File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'win32/autogui'
+require 'spec'
+require 'spec/autorun'
+require 'aruba/api'
+
+# applications
+require File.expand_path(File.dirname(__FILE__) + '/applications/calculator')
+
+# aruba helper, returns full path to files in the aruba tmp folder
+def fullpath(filename)
+  path = File.expand_path(File.join(current_dir, filename))
+  path = `cygpath -w #{path}`.chomp if path.match(/^\/cygdrive/)  # cygwin?
+  path
+end
+
+# return the contents of "filename" in the aruba tmp folder
+def get_file_content(filename)
+  in_current_dir do
+    IO.read(filename)
+  end
+end
+
+Spec::Runner.configure do |config|
+   config.include Aruba::Api
+end

data/spec/watchr.rb

@@ -0,0 +1,144 @@
+# Watchr: Autotest like functionality
+#
+# gem install watchr
+#
+# Run me with:
+#
+#   $ watchr spec/watchr.rb
+
+require 'term/ansicolor'
+
+$c = Term::ANSIColor
+
+def getch
+  state = `stty -g`
+  begin
+    `stty raw -echo cbreak`
+    $stdin.getc
+  ensure
+    `stty #{state}`
+  end
+end
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+def all_feature_files
+  Dir['features/*.feature']
+end
+
+def all_spec_files
+  files = Dir['spec/**/*_spec\.rb']
+end
+
+def run(cmd)
+
+  pid = fork do
+    puts "\n"
+    print $c.cyan, cmd, $c.clear, "\n"
+    exec(cmd)
+  end
+  Signal.trap('INT') do
+    puts "sending KILL to pid: #{pid}"
+    Process.kill("KILL", pid)
+  end
+  Process.waitpid(pid)
+
+  prompt
+end
+
+def run_all
+  run_all_specs
+  run_default_cucumber
+end
+
+# allow cucumber rerun.txt smarts
+def run_default_cucumber
+  cmd = "cucumber"
+  run(cmd)
+end
+
+def run_all_features
+  cmd = "cucumber #{all_feature_files.join(' ')}"
+  run(cmd)
+end
+
+def run_feature(feature)
+  cmd = "cucumber #{feature}"
+  $last_feature = feature
+  run(cmd)
+end
+
+def run_last_feature
+  run_feature($last_feature) if $last_feature
+end
+
+def run_default_spec
+  cmd = "spec _1.3.1_ --color --format s ./spec"
+  run(cmd)
+end
+
+def run_all_specs
+  cmd = "spec _1.3.1_ --color --format s #{all_spec_files.join(' ')}"
+  p cmd
+  run(cmd)
+end
+
+def run_spec(spec)
+  cmd = "spec _1.3.1_ --color --format s #{spec}"
+  $last_spec = spec
+  run(cmd)
+end
+
+def run_last_spec
+  run_spec($last_spec) if $last_spec
+end
+
+def prompt
+  puts "Ctrl-\\ for menu, Ctrl-C to quit"
+end
+
+# init
+$last_feature = nil
+prompt
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch( '^features/(.*)\.feature'   )   { run_default_cucumber }
+
+watch( '^bin/(.*)'   )   { run_default_cucumber }
+watch( '^lib/(.*)'   )   { run_default_cucumber }
+
+watch( '^features/step_definitions/(.*)\.rb' )   { run_default_cucumber }
+watch( '^features/support/(.*)\.rb' )   { run_default_cucumber }
+
+watch( '^spec/(.*)_spec\.rb'   )   { |m| run_spec(m[0]) }
+# specify just the lib files that have specs
+# TODO: This can be determined automatically from the spec file naming convention
+watch( '^lib/(.*)'   )   { run_default_spec }
+watch( '^spec/applications/(.*)'   )   { run_default_spec }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+
+# Ctrl-\
+Signal.trap('QUIT') do
+
+  puts "\n\nMENU: a = all , f = features  s = specs, l = last feature (#{$last_feature ? $last_feature : 'none'}), q = quit\n\n"
+  c = getch
+  puts c.chr
+  if c.chr == "a"
+    run_all
+  elsif c.chr == "f"
+    run_default_cucumber
+  elsif c.chr == "s"
+    run_all_specs
+  elsif c.chr == "q"
+    abort("exiting\n")
+  elsif c.chr == "l"
+    run_last_feature
+  end
+
+end