osaka 0.2.0 → 0.2.1

data/lib/osaka/applicationwrapper.rb

@@ -1,10 +1,11 @@
 
 module Osaka
 
-  class ConditionAndActionProxy
+  class ConditionProxy
     
-    def initialize(wrapper)
+    def initialize(wrapper, action)
       @wrapper = wrapper
+      @action = action
     end
     
     def create_condition_class_based_on_name(sym)
@@ -14,13 +15,24 @@ module Osaka
 
     def method_missing(sym, *args, &block)
       condition = create_condition_class_based_on_name(sym)
-      @wrapper.enter_nested_action
-      yield unless block.nil?
-      @wrapper.exit_nested_action
-      @wrapper.system_event!("repeat until #{condition.as_script(*args)}; #{@wrapper.nested_action} end repeat")
+      @action.execute(@wrapper, condition, *args, &block)      
     end
   end
   
+  class RepeatAction
+    def execute(wrapper, condition, *args, &block)
+      while (!CheckAction.new.execute(wrapper, condition, *args, &block))
+        yield unless block.nil?
+      end
+    end
+  end
+  
+  class CheckAction
+      def execute(wrapper, condition, *args, &block)
+        wrapper.system_event!("#{condition.as_script(*args)};").strip == "true"
+      end
+    end
+  
   class ExistsCondition
     def as_script(element_to_wait_for)
       "exists #{element_to_wait_for}"
@@ -37,44 +49,33 @@ module Osaka
   
     def initialize(name)
       @name = name
-      @nested = false
     end
     
-    def enter_nested_action
-      @nested = true
-      @nested_action = ""
+    def print_warning(action, message)
+      puts "Osaka WARNING while doing #{action}: #{message}"
     end
     
-    def nested_action
-      @nested_action
-    end
-    
-    def exit_nested_action
-      @nested = false
-    end
-    
-    def execute_script(script)
-      if @nested
-        @nested_action += "#{script};"
-      else 
-        ScriptRunner::execute(script) unless @nested
+    def check_output(output, action)
+      if (!output.empty?)
+        print_warning(action, output)
       end
+      output
     end
     
     def activate
-      tell("activate")
+      check_output( tell("activate"), "activate" )
     end
   
     def quit
-      tell("quit")
+      check_output( tell("quit"), "quit" )
     end
   
     def tell(command)
-      execute_script("tell application \"#{@name}\"; #{command}; end tell")
+      ScriptRunner::execute("tell application \"#{@name}\"; #{command}; end tell")
     end
   
     def system_event!(event)
-      execute_script("tell application \"System Events\"; tell process \"#{@name}\"; #{event}; end tell; end tell")
+      ScriptRunner::execute("tell application \"System Events\"; tell process \"#{@name}\"; #{event}; end tell; end tell")
     end
 
     def system_event(event)
@@ -87,12 +88,16 @@ module Osaka
       wait_until!
     end
     
+    def check
+      ConditionProxy.new(self, CheckAction.new)
+    end
+    
     def wait_until!
-      ConditionAndActionProxy.new(self)
+      ConditionProxy.new(self, RepeatAction.new)
     end
     
     def until!
-      ConditionAndActionProxy.new(self)
+      ConditionProxy.new(self, RepeatAction.new)
     end
         
     def construct_modifier_statement(modifier_keys)
@@ -102,7 +107,7 @@ module Osaka
     end
     
     def keystroke!(key, modifier_keys = [])
-      system_event!("keystroke \"#{key}\"#{construct_modifier_statement(modifier_keys)}")
+      check_output( system_event!("keystroke \"#{key}\"#{construct_modifier_statement(modifier_keys)}"), "keystroke")
       self
     end
     
@@ -112,6 +117,7 @@ module Osaka
     end
         
     def click!(element)
+      # Click seems to often output stuff, but it doesn't have much meaning so we ignore it.
       system_event!("click #{element}")
       self
     end
@@ -121,13 +127,17 @@ module Osaka
       click!(element)
     end
         
-    def set!(element, value)
-      system_event!("set #{element} to \"#{value}\"")
+    def set!(element, location, value)
+      check_output( system_event!("set #{element} of #{location} to \"#{value}\""), "set")
+    end
+    
+    def get!(element, location)
+      system_event!("get #{element} of #{location}")
     end
 
-    def set(element, value)
+    def set(element, location, value)
       activate
-      set!(element, value)
+      set!(element, location, value)
     end
   end
 end

data/lib/osaka/pages.rb

@@ -1,9 +1,10 @@
 
 module Osaka
   class PagesMailMergeDialog
-    attr_accessor :wrapper
+    attr_accessor :wrapper, :location
 
-    def initialize(wrapper)
+    def initialize(location, wrapper)
+      @location = location
       @wrapper = wrapper
     end
   
@@ -13,7 +14,21 @@ module Osaka
       @wrapper.wait_until!.exists("menu button \"PDF\" of #{print_dialog_location}")
       TypicalPrintDialog.new(print_dialog_location, @wrapper)
     end
-  
+        
+    def set_merge_to_new_document
+      set_merge_to_document_printer(1)
+    end
+    
+    def set_merge_to_printer
+      set_merge_to_document_printer(2)
+    end
+    
+  private
+    def set_merge_to_document_printer(value)
+      @wrapper.click("pop up button 2 of #{@location}")
+      @wrapper.wait_until!.exists("menu item #{value} of menu 1 of pop up button 2 of #{@location}")
+      @wrapper.click!("menu item #{value} of menu 1 of pop up button 2 of #{@location}")
+    end    
   end
 
   class Pages < TypicalApplication
@@ -25,7 +40,7 @@ module Osaka
     def mail_merge
       @wrapper.system_event("tell menu bar 1; tell menu \"Edit\"; click menu item 20; end tell; end tell")
       @wrapper.wait_until.exists('button "Merge" of sheet 1 of window 1')
-      PagesMailMergeDialog.new(@wrapper)
+      PagesMailMergeDialog.new("sheet 1 of window 1", @wrapper)
     end
     
     def mail_merge_to_pdf(filename)

data/lib/osaka/scriptrunner.rb

@@ -3,12 +3,15 @@ module Osaka
   
   class ScriptRunnerError < RuntimeError
   end
+  
+  class SystemCommandFailed < RuntimeError
+  end
 
   module ScriptRunner
 
     @@debug_info_enabled = false
 
-    def self.enabled_debug_prints
+    def self.enable_debug_prints
       @@debug_info_enabled = true
     end
 
@@ -21,18 +24,34 @@ module Osaka
     end
   
     def self.execute(applescript)
-      script_commands = applescript.gsub('"', '\\"').split(';')
+      script_commands = applescript.gsub("\"", "\\\"").split(';')
       escaped_commands = "" 
       script_commands.each { |l| 
         escaped_commands += " -e \"#{l.strip}\""
       }
       puts "Executing: osascript#{escaped_commands}" if debug_prints?
-      
-      raise(Osaka::ScriptRunnerError, "Error received while executing: #{applescript}") unless system("osascript#{escaped_commands}")
+
+      output = ""
+      begin
+        output = do_system("osascript#{escaped_commands}")
+      rescue Osaka:: SystemCommandFailed
+        raise(Osaka::ScriptRunnerError, "Error received while executing: #{applescript}")
+      end
+      if (!output.empty? && debug_prints?)
+        puts "Output was: #{output}"
+      end
+      output
     end  
   
     def self.execute_file(scriptName, parameters = "")
-      system("osascript #{scriptName} #{parameters}".strip)
+      do_system("osascript #{scriptName} #{parameters}".strip)
+    end
+
+  private
+    def self.do_system(command)
+      output = `#{command}`
+      raise Osaka::SystemCommandFailed unless $?.success?
+      output
     end
   end
 end

data/lib/osaka/typicalapplication.rb

@@ -10,12 +10,12 @@ module Osaka
     end
   
     def set_filename(filename)
-      @wrapper.set("value of text field 1 of #{@location}", filename)
+      @wrapper.set("value", "text field 1 of #{@location}", filename)
     end
   
     def set_folder(pathname)
-      @wrapper.keystroke("g", [ :command, :shift ]).wait_until.exists ("sheet 1 of #{@location}")
-      @wrapper.set("value of text field 1 of sheet 1 of #{@location}", pathname)
+      @wrapper.keystroke("g", [ :command, :shift ]).wait_until.exists("sheet 1 of #{@location}")
+      @wrapper.set("value", "text field 1 of sheet 1 of #{@location}", pathname)
       @wrapper.click("button \"Go\" of sheet 1 of #{@location}").wait_until.not_exists("sheet 1 of #{@location}")
     end
   
@@ -44,7 +44,7 @@ module Osaka
     end
 
     def save_as_pdf(filename)
-      @wrapper.click!("menu button \"PDF\" of #{@location}").wait_until!.exists ("menu 1 of menu button \"PDF\" of #{@location}")
+      @wrapper.click!("menu button \"PDF\" of #{@location}").wait_until!.exists("menu 1 of menu button \"PDF\" of #{@location}")
       @wrapper.click!("menu item 2 of menu 1 of menu button \"PDF\" of #{@location}").wait_until!.exists('window "Save"')
       save_dialog = create_save_dialog("window \"Save\"", @wrapper)
       save_dialog.save(filename)

data/lib/osaka/version.rb

@@ -1,4 +1,4 @@
 
 module Osaka
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/spec/applicationwrapper_spec.rb

@@ -6,6 +6,11 @@ describe "Osaka::ApplicationWrapper" do
   name = "ApplicationName"
   quoted_name = "\"#{name}\""
   subject { Osaka::ApplicationWrapper.new(name) }
+
+  def check_for_warning(action)
+    Osaka::ScriptRunner.should_receive(:execute).and_return("Blah")
+    subject.should_receive(:print_warning).with(action, "Blah")
+  end
   
   it "Should be able to tell applications to do something" do
     Osaka::ScriptRunner.should_receive(:execute).with("tell application #{quoted_name}; command; end tell")
@@ -16,16 +21,31 @@ describe "Osaka::ApplicationWrapper" do
     Osaka::ScriptRunner.should_receive(:execute).with("tell application #{quoted_name}; activate; quit; end tell")
     subject.tell("activate; quit")
   end
+  
+  it "Should be able to print warning messages" do
+    subject.should_receive(:puts).with("Osaka WARNING while doing action: Message")
+    subject.print_warning("action", "Message")
+  end
 
   it "Has a short-cut method for activation" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/activate/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/activate/).and_return("")
+    subject.activate
+  end
+  
+  it "Should print an Warning message with the ScriptRunner returns text when doing activate" do
+    check_for_warning("activate")
     subject.activate
   end
   
   it "Has a short-cut method for quitting" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/quit/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/quit/).and_return("")
     subject.quit
   end
+  
+  it "Prints a warning message when quit results in some output" do
+    check_for_warning("quit")
+    subject.quit    
+  end
     
   it "Should be able to generate events via the Systems Events" do
     Osaka::ScriptRunner.should_receive(:execute).with(/tell application "System Events"; tell process #{quoted_name}; quit; end tell; end tell/)
@@ -38,24 +58,38 @@ describe "Osaka::ApplicationWrapper" do
     subject.system_event("quit")
   end
   
+  it "Should be able to check whether a specific element exists" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true\n")
+    subject.check.exists("window 1").should == true
+  end
+  
   it "Should be able to wait for for a specific element existing" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window 1;  end repeat/)
+    counter = 0
+    Osaka::ScriptRunner.should_receive(:execute).exactly(5).times.with(/exists window 1/).and_return {
+      counter = counter + 1
+      (counter == 5).to_s
+    }
     subject.wait_until!.exists("window 1")
   end
   
   it "Should be able to wait until exists and activate the application first" do
     subject.should_receive(:activate)
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window 1;  end repeat/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
     subject.wait_until.exists("window 1")
   end
 
   it "Should be able to wait for a specific element to not exist anymore" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until not exists window 1;  end repeat/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/not exists window 1/).and_return("true")
     subject.wait_until!.not_exists("window 1")    
   end
   
   it "Should be able to generate keystroke events" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/).and_return("")
+    subject.keystroke!("p")
+  end
+
+  it "Prints a warning when keystroke results in some outputShould be able to generate keystroke events" do
+    check_for_warning("keystroke")
     subject.keystroke!("p")
   end
   
@@ -66,33 +100,33 @@ describe "Osaka::ApplicationWrapper" do
   end
   
   it "Should be able to do keystrokes with command down" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p" using {command down}/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p" using {command down}/).and_return("")
     subject.keystroke!("p", :command)    
   end
 
   it "Should be able to do keystrokes with option and command down" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p" using {option down, command down}/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p" using {option down, command down}/).and_return("")
     subject.keystroke!("p", [ :option, :command ])    
   end
   
   it "Should be able to do a keystroke and wait until something happen in one easy line" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/)
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window 1;  end repeat/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/).and_return("")
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
     subject.keystroke!("p", []).wait_until!.exists("window 1")
   end
   
   it "Should be able to keystroke_and_wait_until_exists and activate" do
     subject.should_receive(:activate)
-    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/)
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window 1;  end repeat/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/).and_return("")
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
     subject.keystroke("p", []).wait_until!.exists("window 1")    
   end
   
   it "Should be able to do clicks" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/click menu button "PDF"/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/click menu button "PDF"/).and_return("")
     subject.click!('menu button "PDF"')
   end
-  
+
   it "Should be able to do click and activate" do
     subject.should_receive(:activate)
     subject.should_receive(:click!).with("button")
@@ -100,31 +134,50 @@ describe "Osaka::ApplicationWrapper" do
   end
   
   it "Should be able to do clicks and wait until something happened in one easy line" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/click/)
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window;  end repeat/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/click/).and_return("")
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window/).and_return("true")
     subject.click!("button").wait_until!.exists("window")
   end
   
   it "Should be able to click_and_wait_until_exists and activate" do
     subject.should_receive(:activate)
-    Osaka::ScriptRunner.should_receive(:execute).with(/click/)
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window;  end repeat/)
+    Osaka::ScriptRunner.should_receive(:execute).with(/click/).and_return("")
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window/).and_return("true")
     subject.click("button").wait_until!.exists("window")
   end
     
   it "Should be able to set a value to an element" do
-    subject.should_receive(:system_event!).with(/set value of window to "newvalue"/)
-    subject.set!("value of window", "newvalue")
+    check_for_warning("set")
+    subject.set!("value", "window", "newvalue")
+  end
+
+  it "Prints a warning when setting and element and output is received" do
+    subject.should_receive(:system_event!).with(/set value of window to "newvalue"/).and_return("")
+    subject.set!("value", "window", "newvalue")
+  end
+  
+  it "Should be able to get a value from an element" do
+    subject.should_receive(:system_event!).with(/get value of window/).and_return("1")
+    subject.get!("value", "window").should == "1"
   end
   
   it "Should be able to set a value and activate" do
     subject.should_receive(:activate)
-    subject.should_receive(:set!).with("value of window", "newvalue")
-    subject.set("value of window", "newvalue")
+    subject.should_receive(:set!).with("value", "window", "newvalue")
+    subject.set("value", "window", "newvalue")
   end
   
   it "Should be able to loop over some script until something happens" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window; tell application \"ApplicationName\"; activate; end tell; end repeat/)
+    counter = 0
+    Osaka::ScriptRunner.should_receive(:execute).exactly(3).times.with(/exists window/).and_return {
+      counter = counter + 1
+      if counter > 2
+        "true"
+      else
+        "false"
+      end
+    }
+    subject.should_receive(:activate).twice
     subject.until!.exists("window") {
       subject.activate
     }

data/spec/pages_spec.rb

@@ -22,7 +22,7 @@ describe "Osaka::Pages" do
     
     subject.mail_merge_to_pdf("filename")
   end
-  
+    
   it "Should be able to select the Mail Merge" do
     expect_system_event('tell menu bar 1; tell menu "Edit"; click menu item 20; end tell; end tell')
     should_wait_until(:exists, 'button "Merge" of sheet 1 of window 1')
@@ -35,4 +35,32 @@ describe "Osaka::Pages" do
     subject.mail_merge.merge
   end
   
+  
 end
+
+describe "Osaka::Pages Mail Merge dialog" do
+  
+  include(*Osaka::ApplicationWrapperExpectations)
+
+  subject { Osaka::PagesMailMergeDialog.new("", nil) }
+  
+  before (:each) do
+    @wrapper = subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object
+    @location = subject.location = "window 1"
+  end
+  
+  it "Should be able to set the mail merge dialog to merge to new document" do
+    expect_click("pop up button 2 of #{@location}")
+    should_wait_until!(:exists, "menu item 1 of menu 1 of pop up button 2 of #{@location}")
+    expect_click!("menu item 1 of menu 1 of pop up button 2 of #{@location}")
+    subject.set_merge_to_new_document
+  end
+  
+  it "Should be able to set the mail merge dialog to merge to printer" do
+    expect_click("pop up button 2 of #{@location}")
+    should_wait_until!(:exists, "menu item 2 of menu 1 of pop up button 2 of #{@location}")
+    expect_click!("menu item 2 of menu 1 of pop up button 2 of #{@location}")
+    subject.set_merge_to_printer    
+  end
+end
+

data/spec/scriptrunner_spec.rb

@@ -5,46 +5,47 @@ describe "Osaka::ScriptRunner" do
   subject { Osaka::ScriptRunner }
 
   it "Should be able to run single-line text as osascript" do
-    subject.should_receive(:system).with('osascript -e "random number"').and_return(true)
-    subject.execute("random number")
+    subject.should_receive(:do_system).with('osascript -e "random number"').and_return("")
+    subject.execute("random number").should == ""
   end
   
   it "Should escape quotes when passing text" do
-    subject.should_receive(:system).with('osascript -e "say \\"hello\\""').and_return(true)
+    subject.should_receive(:do_system).with('osascript -e "say \\"hello\\""').and_return("")
     subject.execute('say "hello"')
   end
   
   it "Should be able to run on debug printing" do
-    subject.should_receive(:system).and_return(true)
+    subject.should_receive(:do_system).and_return("Blah blah blah")
     subject.should_receive(:puts).with('Executing: osascript -e "random number"')
-    Osaka::ScriptRunner::enabled_debug_prints
+    subject.should_receive(:puts).with('Output was: Blah blah blah')
+    Osaka::ScriptRunner::enable_debug_prints
     subject.execute("random number")
     Osaka::ScriptRunner::disable_debug_prints
   end
   
   it "Should not print any debugging information by default " do
-    subject.should_receive(:system).and_return(true)
+    subject.should_receive(:do_system).and_return("")
     subject.should_not_receive(:puts)
     subject.execute("random number")
   end
   
   it "Should be able to define multi-line statements using ; as a separator" do
-    subject.should_receive(:system).with('osascript -e "tell application \\"Calculator\\"" -e "activate" -e "end tell"').and_return(true)
+    subject.should_receive(:do_system).with('osascript -e "tell application \\"Calculator\\"" -e "activate" -e "end tell"').and_return("")
     subject.execute('tell application "Calculator"; activate; end tell')
   end
   
   it "Should raise an exception witha proper error message when the applescript fails" do
-    subject.should_receive(:system).and_return(false)
+    subject.should_receive(:do_system).and_raise(Osaka::SystemCommandFailed)
     lambda {subject.execute("Fuck off!")}.should raise_error(Osaka::ScriptRunnerError, "Error received while executing: Fuck off!")
   end
   
   it "Should be able to execute an file containing applescript" do
-    subject.should_receive(:system).with('osascript script.scpt').and_return(true)
+    subject.should_receive(:do_system).with('osascript script.scpt').and_return(true)
     subject.execute_file("script.scpt")
   end
   
   it "Should be able to pass parameters to an applescript" do
-    subject.should_receive(:system).with('osascript script.scpt a b c').and_return(true)
+    subject.should_receive(:do_system).with('osascript script.scpt a b c').and_return(true)
     subject.execute_file("script.scpt", "a b c")    
   end
 end

data/spec/typicalapplication_spec.rb

@@ -95,14 +95,14 @@ describe "Osaka::TypicalApplication" do
     end
     
     it "Should be able to set the filename" do
-      subject.wrapper.should_receive(:set).with('value of text field 1 of window 1', "filename")
+      subject.wrapper.should_receive(:set).with('value', 'text field 1 of window 1', "filename")
       subject.set_filename("filename")
     end
     
     it "Should be able to set the path" do
       expect_keystroke("g", [ :command, :shift ])
       should_wait_until(:exists,  "sheet 1 of window 1")
-      subject.wrapper.should_receive(:set).with("value of text field 1 of sheet 1 of window 1", "path")
+      subject.wrapper.should_receive(:set).with("value", "text field 1 of sheet 1 of window 1", "path")
       expect_click('button "Go" of sheet 1 of window 1')
       should_wait_until(:not_exists, "sheet 1 of window 1")
       subject.set_folder("path")

metadata

@@ -2,7 +2,7 @@
 name: osaka
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Bas Vodde
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-18 00:00:00 +08:00
+date: 2012-02-26 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency