osaka 0.3.2 → 0.4.0

data/README.rdoc

@@ -6,9 +6,20 @@ This is a Ruby 1.9 library for automating work via GUI on Mac (using OSA/Applesc
 
   $ sudo gem install osaka
 
+= Note before use
+
+You have to enable the "access for assistive devices" for the scripts to run. You do this via System Preferences -> Universal Access / Accessibility -> "enable access for assistive devices"
+
 = How to use
 
 Examples:
+
+  #### Example: Using Osaka Flows to merge multiple keynote files.
+
+  require 'osaka'
+
+  # Convert all keynote files in dir "dirname" with the search pattern "pattern" and write it in "results.key"
+  CommonFlows.keynote_combine_files_from_directory_sorted("results.key", "dirname", /^\d+.*\.key$/)  
   
   #### Example: Controlling Keynote
 
@@ -46,24 +57,37 @@ Examples:
   app.save
   app.quit
 
-  #### Example: Using the Application Wrapper (lower-level)
+  #### Example: Using the lower-level remote control
 
   require 'osaka'
 
   # Create an application wrapper
-  calculator = Osaka::ApplicationWrapper.new("Calculator")
+  calculator = Osaka::RemoteControl.new("Calculator")
 
   # Start the application
   calculator.activate
+  calculator.focus
 
   # Control the calculator
-  calculator.click('button "1"  of group 2 of window "Calculator"')
-  calculator.click('button "+"  of group 2 of window "Calculator"')
-  calculator.click('button "4"  of group 2 of window "Calculator"')
-  calculator.click('button "="  of group 2 of window "Calculator"')
+  calculator.click!(at.button("1").group(2))
+  calculator.click!(at.button("+").group(2))
+  calculator.click!(at.button("4").group(2))
+  calculator.click!(at.button("=").group(2))
 
   calculator.quit
 
+  #### Example: Same as above using the Calculator class
+
+  require 'osaka'
+  calculator = Osaka::Calculator.new
+  calculator.activate
+  calculator.click("1")
+  calculator.click("+")
+  calculator.click("4")
+  calculator.click("=")
+  calculator.quit
+
+
 API document: To be done.
 
 = Source code
@@ -72,9 +96,9 @@ https://github.com/basvodde/osaka
 
 The license of this source is "BSD Licence"
 
-= Note on current version (0.1.1)
+= Note on current version (0.4.0)
 
-Currently the functionality is fairly limited. It can be easily expanded by writing more application wrappers with convenient interfaces for controlling specific application. If you write some for common application or extend the ones, please submit a merge request :)
+Current version is reasonably well tested on snow leopard, lion and mountain lion. It has been used to automate keynote, pages, and numbers work. Additional functionality would be useful but hasn't been needed yet. If you do need additional functionality, please extend it and send me a pull request :)
 
 = Supported environments
 

data/lib/osaka/calculator.rb

@@ -1,33 +1,34 @@
 
 module Osaka
   class Calculator < TypicalApplication
-    attr_accessor :wrapper
+
+    attr_accessor :control
     
     def initialize
       @name = "Calculator"
-      @wrapper = ApplicationWrapper.new("Calculator")
-      @wrapper.set_current_window(@name)
+      @control = RemoteControl.new("Calculator")
+      control.set_current_window(@name)
     end
     
     def activate
       super
-      if (@wrapper.current_window_name.empty?)
+      if (control.current_window_name.empty?)
         wait_for_new_window([])
-        @wrapper.set_current_window(@wrapper.window_list[0])
+        control.set_current_window(control.window_list[0])
       end
     end
     
     def click(key)
-      @wrapper.click!(at.button(key).group(2))
+      control.click!(at.button(key).group(2))
     end
     
     def key(k)
-      @wrapper.keystroke(k)
+      control.keystroke(k)
     end
     
     def result
-      @wrapper.wait_until_exists!(at.static_text(1).group(1))
-      @wrapper.get!('value', at.static_text(1).group(1))
+      control.wait_until_exists!(at.static_text(1).group(1))
+      control.get!('value', at.static_text(1).group(1))
     end
   end
 end

data/lib/osaka/keynote.rb

@@ -12,14 +12,14 @@ module Osaka
     end
 
     def create_print_dialog(location)
-      KeynotePrintDialog.new(location, @wrapper)
+      KeynotePrintDialog.new(control.name, at.window("Print"))
     end
     
     def select_all_slides
-      if @wrapper.exists(at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1))
-        @wrapper.click(at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1))
+      if control.exists?(at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1))
+        control.click(at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1))
       else
-        @wrapper.click(at.button("Slides").group(1).outline(1).scroll_area(1).splitter_group(1).splitter_group(1))
+        control.click(at.button("Slides").group(1).outline(1).scroll_area(1).splitter_group(1).splitter_group(1))
       end
       select_all
     end

data/lib/osaka/location.rb

@@ -17,6 +17,10 @@ module Osaka
       Location.new(to_s + " of " + other_location.to_s)
     end
     
+    def top_level_element
+      Location.new(@location_name[/window (.*)$/])
+    end
+    
     def to_s
       @location_name
     end

data/lib/osaka/numbers.rb

@@ -7,7 +7,7 @@ module Osaka
     end
   
     def fill_cell(column, row, value)
-      @wrapper.tell("tell document 1; tell sheet 1; tell table 1; set value of cell #{column} of row #{row} to \"#{value}\"; end tell; end tell; end tell")
+      control.tell("tell document 1; tell sheet 1; tell table 1; set value of cell #{column} of row #{row} to \"#{value}\"; end tell; end tell; end tell")
     end
   end
 end

data/lib/osaka/osakaexpectations.rb

@@ -0,0 +1,132 @@
+
+module Osaka
+  module OsakaExpectations
+        
+    def simulate_mac_version(version)
+      control.should_receive(:mac_version).and_return(version)
+    end
+        
+    def expect_execute_osascript(command = nil)
+      return Osaka::ScriptRunner.should_receive(:execute).with(command) unless command.nil?
+      Osaka::ScriptRunner.should_receive(:execute)
+    end
+    
+    def expect_clone
+      control.should_receive(:clone)
+    end
+    
+    def expect_activate
+      control.should_receive(:activate)
+    end
+
+    def expect_launch
+      control.should_receive(:launch)
+    end
+    
+    def expect_focus
+      control.should_receive(:focus)
+    end
+
+    def expect_focus!
+      control.should_receive(:focus!)
+    end
+    
+    def expect_set_current_window(name)
+      control.should_receive(:set_current_window).with(name)
+    end
+    
+    def expect_running?
+      control.should_receive(:running?)
+    end
+    
+    def expect_quit
+      control.should_receive(:quit)
+    end
+    
+    def expect_window_list
+      control.should_receive(:window_list)
+    end
+    
+    def expect_current_window_name
+      control.should_receive(:current_window_name)
+    end
+    
+    def expect_set(element, location, value)
+      control.should_receive(:set).with(element, location, value)
+    end
+
+    def expect_set!(element, location, value)
+      control.should_receive(:set!).with(element, location, value)
+    end
+    
+    def expect_get_app!(element)
+      control.should_receive(:get_app!).with(element)
+    end
+    
+    def expect_keystroke(key, modifier = [])
+      control.should_receive(:keystroke).with(key, modifier).and_return(control) unless modifier.empty?
+      control.should_receive(:keystroke).with(key).and_return(control) if modifier.empty?
+    end
+    
+    def expect_keystroke!(key, modifier = [])
+      control.should_receive(:keystroke!).with(key, modifier).and_return(control) unless modifier.empty?
+      control.should_receive(:keystroke!).with(key).and_return(control) if modifier.empty?
+    end
+    
+    def expect_click!(location)
+      control.should_receive(:click!).with(location).and_return(control)
+    end
+    
+    def expect_click(location)
+      control.should_receive(:click).with(location).and_return(control)
+    end
+    
+    def expect_click_menu_bar(menu_item, menu_name)
+      control.should_receive(:click_menu_bar).with(menu_item, menu_name).and_return(control)
+    end
+    
+    def expect_get!(element, location)
+      control.should_receive(:get!).with(element, location)
+    end
+    
+    def expect_tell(do_this)
+      control.should_receive(:tell).with(do_this)
+    end
+    
+    def expect_system_event(event)
+      control.should_receive(:system_event).with(event)
+    end
+
+    def expect_system_event!(event)
+      control.should_receive(:system_event!).with(event)
+    end
+    
+    def expect_exists?(location)
+      control.should_receive(:exists?).with(location)
+    end
+    
+    def expect_not_exists?(location)
+      control.should_receive(:not_exists?).with(location)
+    end
+    
+    def expect_wait_until_exists(*location)
+      control.should_receive(:wait_until_exists).with(*location)
+    end
+
+    def expect_wait_until_exists!(*location)
+      control.should_receive(:wait_until_exists!).with(*location)
+    end
+    
+    def expect_wait_until_not_exists(location)
+      control.should_receive(:wait_until_not_exists).with(location)
+    end
+
+    def expect_wait_until_not_exists!(location, action)
+      control.should_receive(:wait_until_not_exists!).with(location)
+    end
+    
+    def expect_until_not_exists!(element)
+      control.should_receive(:until_not_exists!).with(element).and_yield
+    end  
+  end
+end

data/lib/osaka/pages.rb

@@ -1,18 +1,18 @@
 
 module Osaka
   class PagesMailMergeDialog
-    attr_accessor :wrapper, :location
+    attr_accessor :control, :location
 
-    def initialize(location, wrapper)
+    def initialize(location, control)
       @location = location
-      @wrapper = wrapper
+      @control = control
     end
   
     def merge
-      @wrapper.click!(at.button("Merge").sheet(1))
-      print_dialog_location = 'window "Print"' 
-      @wrapper.wait_until_exists!("menu button \"PDF\" of #{print_dialog_location}")
-      TypicalPrintDialog.new(print_dialog_location, @wrapper)
+      control.click!(at.button("Merge").sheet(1))
+      print_dialog_location = at.window("Print")
+      control.wait_until_exists!(at.menu_button("PDF") + print_dialog_location)
+      TypicalPrintDialog.new(control.name, print_dialog_location)
     end
         
     def set_merge_to_new_document
@@ -25,9 +25,9 @@ module Osaka
     
   private
     def set_merge_to_document_printer(value)
-      @wrapper.click(at.pop_up_button(2).sheet(1))
-      @wrapper.wait_until_exists!(at.menu_item(value).menu(1).pop_up_button(2).sheet(1))
-      @wrapper.click!(at.menu_item(value).menu(1).pop_up_button(2).sheet(1))
+      control.click(at.pop_up_button(2).sheet(1))
+      control.wait_until_exists!(at.menu_item(value).menu(1).pop_up_button(2).sheet(1))
+      control.click!(at.menu_item(value).menu(1).pop_up_button(2).sheet(1))
     end    
   end
 
@@ -38,9 +38,9 @@ module Osaka
     end
   
     def mail_merge
-      @wrapper.click_menu_bar(at.menu_item(20), "Edit")
-      @wrapper.wait_until_exists(at.button("Merge").sheet(1))
-      PagesMailMergeDialog.new(at.sheet(1), @wrapper)
+      control.click_menu_bar(at.menu_item(20), "Edit")
+      control.wait_until_exists(at.button("Merge").sheet(1))
+      PagesMailMergeDialog.new(at.sheet(1), control)
     end
     
     def mail_merge_to_pdf(filename)

data/lib/osaka/{applicationwrapper.rb → remotecontrol.rb}

@@ -1,20 +1,23 @@
 
+require 'timeout'
+
 module Osaka
 
   class InvalidLocation < RuntimeError
   end
   
-  class ApplicationWrapper
+  class RemoteControl
   
     attr_reader :name
+    attr_accessor :base_location
     
-    def initialize(name)
+    def initialize(name, base_location = Location.new(""))
       @name = name
-      @window = Location.new("")
+      @base_location = base_location
     end
     
     def ==(obj)
-      @name == obj.name && current_window_name == obj.current_window_name
+      @name == obj.name && base_location == obj.base_location
     end
     
     def tell(command)
@@ -41,6 +44,10 @@ module Osaka
     def activate
       check_output( tell("activate"), "activate" )
     end
+    
+    def launch
+      check_output( tell("launch"), "launch" )
+    end
   
     def quit
       keystroke("q", :command)
@@ -51,31 +58,38 @@ module Osaka
       system_event!(event)
     end
 
-    def exists(location)
+    def exists?(location)
       system_event!("exists #{construct_location(location)}").strip == "true"
     end
 
-    def not_exists(location)
+    def not_exists?(location)
       system_event!("not exists #{construct_location(location)}").strip == "true"
     end
         
     def wait_until(locations, action)
-      while(true)
-          locations.flatten.each { |location| 
-            return location if yield location
+      
+      begin
+        Timeout::timeout(5) {
+          while(true)
+              locations.flatten.each { |location| 
+                return location if yield location
+            }
+            action.() unless action.nil?
+          end
         }
-        action.() unless action.nil?
+      rescue Exception => e
+        raise Osaka::TimeoutError, "Timed out while waiting for: #{locations.to_s}"
       end
     end
     
-    def wait_until_exists(*locations)
+    def wait_until_exists(*locations, &action)
       activate
-      wait_until_exists!(locations)
+      wait_until_exists!(*locations, &action)
     end
     
     def wait_until_exists!(*locations, &action)
       wait_until(locations, action) { |location|
-        exists(location)
+        exists?(location)
       }
     end
     
@@ -84,12 +98,12 @@ module Osaka
 
     def wait_until_not_exists(*locations, &action)
       activate
-      wait_until_not_exists!(*locations, action)
+      wait_until_not_exists!(*locations, &action)
     end
 
     def wait_until_not_exists!(*locations, &action)
       wait_until(locations, action) { |location|
-        not_exists(location)
+        not_exists?(location)
       }
     end
 
@@ -116,7 +130,7 @@ module Osaka
     def keystroke(key, modifier_keys = [])
       activate
       focus
-      keystroke!(key, modifier_keys)
+      (modifier_keys == []) ? keystroke!(key) : keystroke!(key, modifier_keys)
     end
         
     def click!(element)
@@ -141,21 +155,23 @@ module Osaka
       check_output( system_event!("set #{element}#{construct_prefixed_location(location)} to #{encoded_value}"), "set")
     end
     
-    def focus
-      current_windows = window_list
-      currently_active_window = current_windows[0]
-      currently_active_window ||= ""
-      
-      if current_window_invalid?(current_windows)
-        @window = at.window(currently_active_window) unless currently_active_window.nil?
+    def focus      
+      if (base_location.to_s.empty? || not_exists?(base_location))
+        currently_active_window = window_list[0]
+        currently_active_window ||= ""
+        @base_location = (currently_active_window.to_s.empty?) ? Location.new("") : at.window(currently_active_window)
       end
 
-      set!("value", "attribute \"AXMain\"", true) unless currently_active_window == current_window_name
+      focus!
+    end
+    
+    def focus!
+      system_event!("set value of attribute \"AXMain\" of #{base_location.top_level_element} to true") unless base_location.top_level_element.to_s.empty?
     end
     
     def form_location_with_window(location)
       new_location = Location.new(location)
-      new_location += @window unless new_location.has_top_level_element?
+      new_location += @base_location unless new_location.has_top_level_element?
       new_location
     end
     
@@ -188,21 +204,42 @@ module Osaka
     end 
     
     def set_current_window(window_name)
-      @window = at.window(window_name)
+      @base_location = at.window(window_name)
     end
     
     def current_window_name
-      matchdata = @window.to_s.match(/^window "(.*)"/)
+      matchdata = @base_location.to_s.match(/window "(.*)"/)
       return "" if matchdata.nil? || matchdata[1].nil?
       matchdata[1]
     end
     
-    def current_window_location
-      @window
+    def current_window_invalid?(window_list)
+      @base_location.to_s.empty? || window_list.index(current_window_name).nil?
+    end
+
+    def mac_version
+      @mac_version_string ||= Osaka::ScriptRunner.execute("system version of (system info)").strip
+      @mac_version ||= case @mac_version_string
+        when /^10.6.*/
+          :snow_leopard
+        when /^10.7.*/
+          :lion
+        when /^10.8.*/
+          :mountain_lion
+        else
+          :other
+        end
+        
+    end
+    
+    def mac_version_string
+      mac_version
+      @mac_version_string
     end
     
-    def current_window_invalid?(window_list)
-      @window.to_s.empty? || window_list.index(current_window_name).nil?
+    
+    def convert_mac_version_string_to_symbol(version_string)
+      
     end
     
   end

data/lib/osaka/scriptrunner.rb

@@ -7,6 +7,9 @@ module Osaka
   class SystemCommandFailed < RuntimeError
   end
 
+  class TimeoutError < RuntimeError
+  end
+
   class VersioningError < RuntimeError
   end
   
@@ -14,9 +17,10 @@ module Osaka
 
     @@debug_info_enabled = false
 
-    def self.enable_debug_prints(debug_info_format = :plain_text)
+    def self.enable_debug_prints(debug_info_format = :plain_text, filename = "")
       @@debug_info_enabled = true
       @@debug_info_format = debug_info_format
+      @@debug_info_script_filename = filename
     end
 
     def self.disable_debug_prints
@@ -39,6 +43,10 @@ module Osaka
         elsif (@@debug_info_format == :short_html)
           debug_output = applescript
           debug_output += "<br>"
+        elsif (@@debug_info_format == :script)
+          File.open(@@debug_info_script_filename, File::WRONLY|File::APPEND|File::CREAT, 0755) { |file|
+            file.puts("osascript#{escaped_commands}")
+          }
         end        
         puts debug_output
       end

data/lib/osaka/textedit.rb

@@ -1,19 +1,19 @@
 
 module Osaka
   class TextEdit < TypicalApplication
-    attr_accessor :wrapper
+    attr_accessor :control
     
     def initialize
       @name = "TextEdit"
-      @wrapper = ApplicationWrapper.new("TextEdit")
+      @control = RemoteControl.new("TextEdit")
     end
     
     def type(text)
-      @wrapper.keystroke(text)
+      control.keystroke(text)
     end
     
     def text
-      @wrapper.get!("value", 'text area 1 of scroll area 1')
+      control.get!("value", 'text area 1 of scroll area 1')
     end
     
   end