osaka 0.3.0 → 0.3.1

data/lib/osaka/applicationwrapper.rb

@@ -4,50 +4,6 @@ module Osaka
   class InvalidLocation < RuntimeError
   end
   
-  class ConditionProxy
-    
-    def initialize(wrapper, action)
-      @wrapper = wrapper
-      @action = action
-    end
-    
-    def create_condition_class_based_on_name(sym)
-      classname = "#{sym.to_s[0].upcase}#{sym.to_s[1..-1]}Condition"
-      eval(classname).new
-    end
-
-    def method_missing(sym, *args, &block)
-      condition = create_condition_class_based_on_name(sym)
-      @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(wrapper, *args)};").strip == "true"
-    end
-  end
-  
-  class ExistsCondition
-    def as_script(wrapper, element_to_check)
-      "exists #{wrapper.construct_location(element_to_check)}"
-    end
-  end
-  
-  class Not_existsCondition
-    def as_script(wrapper, element_to_check)
-      "not exists #{wrapper.construct_location(element_to_check)}"
-    end
-  end
-  
   class ApplicationWrapper
   
     attr_reader :name
@@ -95,22 +51,51 @@ module Osaka
       system_event!(event)
     end
 
-    def wait_until
-      activate
-      wait_until!
+    def exists(location)
+      system_event!("exists #{construct_location(location)}").strip == "true"
     end
-    
-    def check
-      ConditionProxy.new(self, CheckAction.new)
+
+    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
+        }
+        action.() unless action.nil?
+      end
     end
     
-    alias check! check
+    def wait_until_exists(*locations)
+      activate
+      wait_until_exists!(locations)
+    end
     
-    def until!
-      ConditionProxy.new(self, RepeatAction.new)
+    def wait_until_exists!(*locations, &action)
+      wait_until(locations, action) { |location|
+        exists(location)
+      }
     end
     
-    alias wait_until! until!
+    alias until_exists wait_until_exists
+    alias until_exists! wait_until_exists!
+
+    def wait_until_not_exists(*locations, &action)
+      activate
+      wait_until_not_exists!(*locations, action)
+    end
+
+    def wait_until_not_exists!(*locations, &action)
+      wait_until(locations, action) { |location|
+        not_exists(location)
+      }
+    end
+
+    alias until_not_exists wait_until_not_exists
+    alias until_not_exists! wait_until_not_exists!
+
         
     def construct_modifier_statement(modifier_keys)
       modified_key_string = [ modifier_keys ].flatten.collect! { |mod_key| mod_key.to_s + " down"}.join(", ")
@@ -118,8 +103,13 @@ module Osaka
       modifier_command
     end
     
+    def construct_key_statement(key_keys)
+      return "return" if key_keys == :return
+      "\"#{key_keys}\""
+    end
+    
     def keystroke!(key, modifier_keys = [])
-      check_output( system_event!("keystroke \"#{key}\"#{construct_modifier_statement(modifier_keys)}"), "keystroke")
+      check_output( system_event!("keystroke #{construct_key_statement(key)}#{construct_modifier_statement(modifier_keys)}"), "keystroke")
       self
     end
     

data/lib/osaka/applicationwrapperexpectations.rb

@@ -1,22 +1,37 @@
 
 module Osaka
   module ApplicationWrapperExpectations
-
-    def should_wait_until(wait_condition, wait_element)
-      should_do_with_condition(:wait_until, wait_condition, wait_element)
+    
+    def expect_clone
+      @wrapper.should_receive(:clone)
+    end
+    
+    def expect_activate
+      @wrapper.should_receive(:activate)
+    end
+    
+    def expect_focus
+      @wrapper.should_receive(:focus)
+    end
+    
+    def expect_set_current_window(name)
+      @wrapper.should_receive(:set_current_window).with(name)
     end
     
-    def should_wait_until!(wait_condition, wait_element)
-      should_do_with_condition(:wait_until!, wait_condition, wait_element)
+    def expect_running?
+      @wrapper.should_receive(:running?)
     end
     
-    def should_check!(condition, element, return_value)
-      should_do_with_condition(:check!, condition, element).and_return(return_value)
+    def expect_quit
+      @wrapper.should_receive(:quit)
     end
     
-    def should_do_until!(condition, element)
-      should_do_with_condition(:until!, condition, element).and_yield
-      yield
+    def expect_window_list
+      @wrapper.should_receive(:window_list)
+    end
+    
+    def expect_set(element, location, value)
+      @wrapper.should_receive(:set).with(element, location, value)
     end
     
     def expect_keystroke(key, modifier = [])
@@ -49,13 +64,24 @@ module Osaka
       @wrapper.should_receive(:system_event).with(event)
     end
     
-private
-    def should_do_with_condition(command, condition, element)
-      condition_proxy = double(:ConditionAndActionProxy)
-      @wrapper.should_receive(command).and_return(condition_proxy)
-      condition_proxy.should_receive(condition).with(element)
+    def expect_exists(location)
+      @wrapper.should_receive(:exists).with(location)
+    end
+    
+    def expect_wait_until_exists(location)
+      @wrapper.should_receive(:wait_until_exists).with(location)
+    end
+
+    def expect_wait_until_exists!(*location)
+      @wrapper.should_receive(:wait_until_exists!).with(*location)
+    end
+    
+    def expect_wait_until_not_exists(location)
+      @wrapper.should_receive(:wait_until_not_exists).with(location)
     end
-  
     
+    def expect_until_not_exists!(element)
+      @wrapper.should_receive(:until_not_exists!).with(element).and_yield
+    end  
   end
 end

data/lib/osaka/calculator.rb

@@ -26,6 +26,7 @@ module Osaka
     end
     
     def result
+      @wrapper.wait_until_exists!(at.static_text(1).group(1))
       @wrapper.get!('value', at.static_text(1).group(1))
     end
   end

data/lib/osaka/keynote.rb

@@ -16,7 +16,7 @@ module Osaka
     end
     
     def select_all_slides
-      if @wrapper.check!.exists(at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1))
+      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))
       else
         @wrapper.click(at.button("Slides").group(1).outline(1).scroll_area(1).splitter_group(1).splitter_group(1))

data/lib/osaka/pages.rb

@@ -11,7 +11,7 @@ module Osaka
     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}")
+      @wrapper.wait_until_exists!("menu button \"PDF\" of #{print_dialog_location}")
       TypicalPrintDialog.new(print_dialog_location, @wrapper)
     end
         
@@ -26,7 +26,7 @@ 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.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))
     end    
   end
@@ -39,10 +39,7 @@ module Osaka
   
     def mail_merge
       @wrapper.click_menu_bar(at.menu_item(20), "Edit")
-      # @wrapper.click!(at.menu_bar_item("Edit").menu_bar(1))
-      # @wrapper.wait_until.exists(at.menu(1).menu_bar_item("Edit").menu_bar(1))
-      # @wrapper.click!(at.menu_item(20).menu(1).menu_bar_item("Edit").menu_bar(1))
-      @wrapper.wait_until.exists(at.button("Merge").sheet(1))
+      @wrapper.wait_until_exists(at.button("Merge").sheet(1))
       PagesMailMergeDialog.new(at.sheet(1), @wrapper)
     end
     

data/lib/osaka/scriptrunner.rb

@@ -7,6 +7,9 @@ module Osaka
   class SystemCommandFailed < RuntimeError
   end
 
+  class VersioningError < RuntimeError
+  end
+  
   module ScriptRunner
 
     @@debug_info_enabled = false

data/lib/osaka/textedit.rb

@@ -8,14 +8,6 @@ module Osaka
       @wrapper = ApplicationWrapper.new("TextEdit")
     end
     
-    def activate
-      super
-      if (@wrapper.current_window_name.empty?)
-        wait_for_new_window([])
-        @wrapper.set_current_window(@wrapper.window_list[0])
-      end
-    end
-    
     def type(text)
       @wrapper.keystroke(text)
     end

data/lib/osaka/typicalapplication.rb

@@ -1,4 +1,4 @@
-
+# encoding: utf-8
 module Osaka
   
   class TypicalSaveDialog
@@ -15,13 +15,13 @@ module Osaka
     end
   
     def set_folder(pathname)
-      @wrapper.keystroke("g", [ :command, :shift ]).wait_until.exists(at.sheet(1) + @self_location)
+      @wrapper.keystroke("g", [ :command, :shift ]).wait_until_exists(at.sheet(1) + @self_location)
       @wrapper.set("value", at.text_field(1).sheet(1) + @self_location, pathname)
-      @wrapper.click(at.button("Go").sheet(1) + @self_location).wait_until.not_exists(at.sheet(1) + @self_location)
+      @wrapper.click(at.button("Go").sheet(1) + @self_location).wait_until_not_exists(at.sheet(1) + @self_location)
     end
   
     def click_save
-      @wrapper.click(at.button("Save") + @self_location).wait_until.not_exists(@self_location)
+      @wrapper.click(at.button("Save") + @self_location).wait_until_not_exists(@self_location)
     end
   
     def save(filename)
@@ -45,15 +45,18 @@ module Osaka
     end
 
     def save_as_pdf(filename)
-      @wrapper.click!(at.menu_button("PDF") + @parent).wait_until!.exists(at.menu(1).menu_button("PDF") + @parent)
-      @wrapper.click!(at.menu_item(2).menu(1).menu_button("PDF") + @parent).wait_until!.exists('window "Save"')
-      save_dialog = create_save_dialog(at.window("Save"), @wrapper)
+      @wrapper.click!(at.menu_button("PDF") + @parent).wait_until_exists!(at.menu(1).menu_button("PDF") + @parent)
+      @wrapper.click!(at.menu_item(2).menu(1).menu_button("PDF") + @parent)
+      
+      save_location = @wrapper.wait_until_exists!(at.window("Save"), at.sheet(1).window("Print"))      
+      save_dialog = create_save_dialog(save_location, @wrapper)
       save_dialog.save(filename)
       
-      @wrapper.until!.not_exists(@parent) {
+      @wrapper.until_not_exists!(@parent) {
         # Weird, but sometimes the dialog "hangs around" and clicking this checkbox will make it go away.
         # Anyone who knows a better solution, please let me know!
-        @wrapper.click!(at.checkbox(1).window("Print"))
+        # This is for snow leopard
+        @wrapper.click!(at.checkbox(1) + @parent) if @wrapper.exists(at.checkbox(1) + @parent)
       }
     end
   end
@@ -77,6 +80,11 @@ module Osaka
       @wrapper = ApplicationWrapper.new(name)
     end
     
+    def initialize_copy(other)
+      super
+      @wrapper = other.wrapper.clone
+    end
+    
     def get_info
       script_info = @wrapper.tell("get info for (path to application \"#{@name}\")")
       ApplicationInfo.new(script_info)
@@ -90,7 +98,7 @@ module Osaka
 
     def wait_for_window_and_dialogs_to_close(option)
       if (option != :user_chose)
-        @wrapper.until!.not_exists(@wrapper.current_window_location) {
+        @wrapper.until_not_exists!(@wrapper.current_window_location) {
           close_dialog_sheet_with_dont_save
         }
       end
@@ -105,8 +113,8 @@ module Osaka
     end
     
     def close_dialog_sheet_with_dont_save
-      if (@wrapper.check!.exists(at.sheet(1)))
-        @wrapper.click!(at.button(2).sheet(1))
+      if (@wrapper.exists(at.sheet(1)))
+        @wrapper.click!(at.button("Don’t Save").sheet(1))
       end
     end
     
@@ -117,8 +125,10 @@ module Osaka
       end
     end
 
-    def wait_for_new_window(original_window_list)
-      latest_window_list = original_window_list
+    def do_and_wait_for_new_window
+      @wrapper.activate
+      latest_window_list = original_window_list = @wrapper.window_list
+      yield
       while (original_window_list == latest_window_list)
         latest_window_list = @wrapper.window_list
       end
@@ -126,22 +136,55 @@ module Osaka
     end
     
     def new_document
-      window_list = @wrapper.window_list
-      @wrapper.keystroke("n", :command)
-      @wrapper.set_current_window(wait_for_new_window(window_list))
+      @wrapper.set_current_window(do_and_wait_for_new_window {
+        @wrapper.keystroke("n", :command)
+      })
       @wrapper.focus
     end
     
+    def duplicate_available?
+      @wrapper.exists(at.menu_item("Duplicate").menu(1).menu_bar_item("File").menu_bar(1))
+    end
+    
+    def duplicate
+      unless duplicate_available?
+        raise(Osaka::VersioningError, "MacOS Versioning Error: Duplicate is not available on this Mac version")
+      end
+      new_window = do_and_wait_for_new_window {
+        @wrapper.keystroke("s", [:command, :shift])
+      }
+      new_instance = clone
+      new_instance.wrapper.set_current_window(do_and_wait_for_new_window {
+        @wrapper.keystroke!(:return)
+      })
+      
+      new_instance
+    end
+    
     def save
       @wrapper.keystroke("s", :command)
     end
     
+    def save_pops_up_dialog?
+      @wrapper.exists(at.menu_item("Save…").menu(1).menu_bar_item("File").menu_bar(1))
+    end
+    
     def save_dialog
-      @wrapper.keystroke("s", [:command, :shift]).wait_until.exists(at.sheet(1))
+      if save_pops_up_dialog?
+        save
+        @wrapper.wait_until_exists(at.sheet(1))
+      else
+        @wrapper.keystroke("s", [:command, :shift]).wait_until_exists(at.sheet(1))
+      end
       create_save_dialog(at.sheet(1))
     end
     
     def save_as(filename)
+      if duplicate_available?
+        new_instance = duplicate
+        close
+        @wrapper = new_instance.wrapper.clone
+      end
       dialog = save_dialog
       dialog.save(filename)
       @wrapper.set_current_window(File.basename(filename))
@@ -189,7 +232,7 @@ module Osaka
     end
   
     def print_dialog
-      @wrapper.keystroke("p", :command).wait_until.exists(at.sheet(1))
+      @wrapper.keystroke("p", :command).wait_until_exists(at.sheet(1))
       create_print_dialog(at.sheet(1))
     end
   

data/lib/osaka/version.rb

@@ -1,4 +1,4 @@
 
 module Osaka
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/spec/applicationwrapper_spec.rb

@@ -84,29 +84,37 @@ 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(at.window(1)).should == true
+  it "Should be able to check whether a location exists" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists button 1/).and_return("true\n")
+    subject.exists(at.button(1)).should == true
+  end
+
+  it "Should be able to check whether a location does not exists" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/not exists window 1/).and_return("true\n")
+    subject.not_exists(at.window(1)).should == true    
   end
   
-  it "Should be able to wait for for a specific element existing" do
-    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(at.window(1))
+  it "Should be able to wait until multiple locations exists and return the one that happened" do
+    subject.should_receive(:exists).with(at.button(1)).and_return(false, false, false)
+    subject.should_receive(:exists).with(at.sheet(5)).and_return(false, false, true)
+    subject.wait_until_exists!(at.button(1), at.sheet(5)).should == at.sheet(5)
   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(/exists window 1/).and_return("true")
-    subject.wait_until.exists(at.window(1))
+    subject.should_receive(:wait_until_exists!).with([at.window(1)])
+    subject.wait_until_exists(at.window(1))
   end
 
+  it "Should be able to wait for a specific element and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:wait_until_not_exists!).with(at.window(1), nil)
+    subject.wait_until_not_exists(at.window(1))
+  end
+  
   it "Should be able to wait for a specific element to not exist anymore" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/not exists window 1/).and_return("true")
-    subject.wait_until!.not_exists(at.window(1))    
+    subject.should_receive(:not_exists).with(at.window(1)).and_return(false, false, true)
+    subject.wait_until_not_exists!(at.window(1))    
   end
   
   it "Should be able to generate keystroke events" do
@@ -114,6 +122,11 @@ describe "Osaka::ApplicationWrapper" do
     subject.keystroke!("p")
   end
 
+  it "Should be able to generate return keystroke event" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke return/).and_return("")
+    subject.keystroke!(:return)
+  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")
@@ -139,7 +152,7 @@ describe "Osaka::ApplicationWrapper" do
   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"/).and_return("")
     Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
-    subject.keystroke!("p", []).wait_until!.exists(at.window(1))
+    subject.keystroke!("p", []).wait_until_exists!(at.window(1))
   end
   
   it "Should be able to keystroke_and_wait_until_exists and activate" do
@@ -147,7 +160,7 @@ describe "Osaka::ApplicationWrapper" do
     subject.should_receive(:focus)
     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(at.window(1))    
+    subject.keystroke("p", []).wait_until_exists!(at.window(1))    
   end
   
   it "Should be able to do clicks" do
@@ -164,14 +177,14 @@ describe "Osaka::ApplicationWrapper" do
   it "Should be able to do clicks and wait until something happened in one easy line" do
     Osaka::ScriptRunner.should_receive(:execute).with(/click/).and_return("")
     Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
-    subject.click!("button").wait_until!.exists(at.window(1))
+    subject.click!("button").wait_until_exists!(at.window(1))
   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/).and_return("")
     Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
-    subject.click("button").wait_until!.exists(at.window(1))
+    subject.click("button").wait_until_exists!(at.window(1))
   end
 
   it "Should be able to click on menu bar items" do
@@ -224,17 +237,9 @@ describe "Osaka::ApplicationWrapper" do
   end
     
   it "Should be able to loop over some script until something happens" do
-    counter = 0
-    Osaka::ScriptRunner.should_receive(:execute).exactly(3).times.with(/exists window 1/).and_return {
-      counter = counter + 1
-      if counter > 2
-        "true"
-      else
-        "false"
-      end
-    }
+    Osaka::ScriptRunner.should_receive(:execute).and_return("false", "false", "true")
     subject.should_receive(:activate).twice
-    subject.until!.exists(at.window(1)) {
+    subject.until_exists!(at.window(1)) {
       subject.activate
     }
   end

data/spec/calculator_spec.rb

@@ -40,6 +40,7 @@ describe "Mac GUI Calculator" do
   end
   
   it "Should be able to get the value from the screen" do
+    expect_wait_until_exists!(at.static_text(1).group(1))
     @wrapper.should_receive(:get!).with("value", at.static_text(1).group(1)).and_return("0")
     subject.result.should == "0"
   end

data/spec/integration_calculator_spec.rb

@@ -35,7 +35,6 @@ describe "Integration test using the Calculator" do
   
   it "Should do whole formulas using key" do
     subject.key("100+10*3+99=")
-    sleep 0.5
     subject.result.should == "229"        
   end
   

data/spec/integration_keynote_spec.rb

@@ -4,7 +4,6 @@ require 'osaka'
 describe "Integration tests for Keynote and Common Flows" do
   
   it "Should be able to do a combine with just one file" do
-   
     assets_directory =  File.join(File.dirname(__FILE__), "assets")
     
     keynote_file = File.join(assets_directory, "01_first_slides.key")

data/spec/integration_pages_numbers_mail_merge_spec.rb

@@ -4,7 +4,7 @@ require 'osaka'
 describe "Integration of mail merge flow with Pages and Numbers" do
   
   it "Should mail merge the assets and generate a PDF" do
-  
+    
     assets_directory =  File.join(File.dirname(__FILE__), "assets")
     numbers_data = File.join(assets_directory, "mail_merge_data.numbers")
     pages_template = File.join(assets_directory, "mail_merge_template.pages")

data/spec/integration_textedit_spec.rb

@@ -16,17 +16,17 @@ describe "Integration test using TextEdit" do
   end
   
   it "can type in the window" do
-    subject.activate
+    subject.new_document
     subject.type("Hello World")
     subject.text.should == "Hello World"
+    subject.close(:dont_save)
   end
   
   it "can type in two windows using two instances" do
-    
     editor1 = subject
     editor2 = Osaka::TextEdit.new
         
-    editor1.activate
+    editor1.new_document
     editor2.new_document
     
     editor1.type("Typing in window 1")

data/spec/keynote_spec.rb

@@ -17,7 +17,7 @@ describe "Osaka::Keynote" do
   
   it "Should be possible to select all the slides in the default location" do
     slides_button_location = at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1)    
-    should_check!(:exists, slides_button_location, true)
+    expect_exists(slides_button_location).and_return(true)
     expect_click(slides_button_location)
     subject.should_receive(:select_all)
     subject.select_all_slides
@@ -26,7 +26,7 @@ describe "Osaka::Keynote" do
   it "Should be possible to select all the slides in the alternative location" do
     slides_button_location = at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1)    
     alternative_slides_button_location = at.button("Slides").group(1).outline(1).scroll_area(1).splitter_group(1).splitter_group(1)
-    should_check!(:exists, slides_button_location, false)
+    expect_exists(slides_button_location).and_return(false)
     expect_click(alternative_slides_button_location)
     subject.should_receive(:select_all)
     subject.select_all_slides

data/spec/pages_spec.rb

@@ -27,14 +27,14 @@ describe "Osaka::Pages" do
   it "Should be able to select the Mail Merge" do
     @wrapper.should_receive(:current_window_name).any_number_of_times.and_return("Pages.pages")
     expect_click_menu_bar(at.menu_item(20), "Edit")
-    should_wait_until(:exists, at.button("Merge").sheet(1))
+    expect_wait_until_exists(at.button("Merge").sheet(1))
     subject.mail_merge
   end
 
   it "Should click the merge button of the mail merge dialog" do
     @wrapper.should_receive(:current_window_name).any_number_of_times.and_return("Pages.pages")
     expect_click!(at.button("Merge").sheet(1))
-    should_wait_until!(:exists, at.menu_button("PDF").window("Print"))
+    expect_wait_until_exists!(at.menu_button("PDF").window("Print"))
     subject.mail_merge.merge
   end
 end
@@ -52,14 +52,14 @@ describe "Osaka::Pages Mail Merge dialog" do
   
   it "Should be able to set the mail merge dialog to merge to new document" do
     expect_click(at.pop_up_button(2).sheet(1))
-    should_wait_until!(:exists, at.menu_item(1).menu(1).pop_up_button(2).sheet(1))
+    expect_wait_until_exists!(at.menu_item(1).menu(1).pop_up_button(2).sheet(1))
     expect_click!(at.menu_item(1).menu(1).pop_up_button(2).sheet(1))
     subject.set_merge_to_new_document
   end
   
   it "Should be able to set the mail merge dialog to merge to printer" do
     expect_click(at.pop_up_button(2).sheet(1))
-    should_wait_until!(:exists, at.menu_item(2).menu(1).pop_up_button(2).sheet(1))
+    expect_wait_until_exists!(at.menu_item(2).menu(1).pop_up_button(2).sheet(1))
     expect_click!(at.menu_item(2).menu(1).pop_up_button(2).sheet(1))
     subject.set_merge_to_printer    
   end

data/spec/textedit_spec.rb

@@ -10,22 +10,7 @@ describe "TextEdit" do
   before (:each) do
     @wrapper = subject.wrapper = double("Osaka::ApplicationWrapper")
   end
-  
-  it "should set the window on activation" do
-    @wrapper.should_receive(:activate)
-    @wrapper.should_receive(:current_window_name).and_return("")
-    subject.should_receive(:wait_for_new_window).with([])
-    @wrapper.should_receive(:window_list).and_return(["Untitled"])
-    @wrapper.should_receive(:set_current_window).with("Untitled")
-    subject.activate
-  end
-  
-  it "shouldn't set the window on activation when it is already set" do
-    @wrapper.should_receive(:activate)
-    @wrapper.should_receive(:current_window_name).and_return("Untitled")
-    subject.activate    
-  end
-  
+    
   it "Should be able to type some text" do
     expect_keystroke('Hello World')
     subject.type("Hello World")

data/spec/typicalapplication_spec.rb

@@ -1,4 +1,4 @@
-
+# encoding: utf-8
 require 'osaka'
 
 describe "Osaka::TypicalApplication" do
@@ -16,80 +16,118 @@ describe "Osaka::TypicalApplication" do
     Osaka::ScriptRunner.disable_debug_prints
   end
   
+  it "Should be able to clone TypicalApplications" do
+    expect_clone
+    subject.clone    
+  end
+  
   it "Should pass the right open string to the application osascript" do
     filename = "filename.key"
     expect_tell("open \"#{File.absolute_path(filename)}\"")
-    @wrapper.should_receive(:set_current_window).with(filename)
+    expect_set_current_window(filename)
     subject.open(filename)    
   end
   
   it "Should only get the basename of the filename when it sets the window title." do
     filename = "/root/dirname/filename.key"
     expect_tell("open \"#{File.absolute_path(filename)}\"")
-    @wrapper.should_receive(:set_current_window).with("filename.key")
+    expect_set_current_window("filename.key")
     subject.open(filename)        
   end
   
   it "Should be able to quit" do
-    @wrapper.should_receive(:running?).and_return(true)
-    @wrapper.should_receive(:quit)
+    expect_running?.and_return(true)
+    expect_quit
     subject.quit
   end
   
   it "Should be able to check if its running" do
-    @wrapper.should_receive(:running?)
-    subject.running?
+    expect_running?.and_return(true)
+    subject.running?.should == true
   end
   
   it "Won't quit when the application isn't running" do
-    @wrapper.should_receive(:running?).and_return(false)
+    expect_running?.and_return(false)
     subject.quit(:dont_save)  
   end
   
   it "Should be able to quit without saving" do
-    @wrapper.should_receive(:running?).and_return(true, true, false)
-    @wrapper.should_receive(:quit)
-    should_check!(:exists, at.sheet(1), true)
-    expect_click!(at.button(2).sheet(1))
+    expect_running?.and_return(true, true, false)
+    expect_quit
+    expect_exists(at.sheet(1)).and_return(true)
+    expect_click!(at.button("Don’t Save").sheet(1))
     subject.quit(:dont_save)  
   end
   
-  it "Should be able to wait until a new window exists" do
-    subject.wrapper.should_receive(:window_list).and_return(["new window"])
-    subject.wait_for_new_window([])    
-  end
-  
-  it "Should be able to wait until a new window exists and it takes 4 calls" do
-    counter = 0
-    subject.wrapper.should_receive(:window_list).exactly(4).times.and_return(["new window"]) {
-        counter = counter + 1
-        counter.should <= 5 # Added here so that the test won't end up in an endless loop.
-        counter >= 4 ? [ "new window" ] : []
-      }
-      subject.wait_for_new_window([])    
-  end
-  
-  it "Should be able to create a new document" do    
-    subject.wrapper.should_receive(:window_list)
+  it "Should be able to create a new document" do
+    subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("new_window")    
     expect_keystroke("n", :command)
-    subject.should_receive(:wait_for_new_window).and_return("new_window")
-    subject.wrapper.should_receive(:set_current_window).with("new_window")
-    subject.wrapper.should_receive(:focus)
+    expect_set_current_window("new_window")
+    expect_focus
     subject.new_document
   end
   
+  it "Should be able to do something and wait until a new window pops up" do
+    expect_window_list.and_return(["original window"], ["original window"], ["original window"], ["new window", "original window"])
+    expect_activate
+    code_block_called = false
+    subject.do_and_wait_for_new_window {
+      code_block_called = true
+    }.should == "new window"
+    code_block_called.should == true
+  end
+    
   it "Should be able to save" do
     expect_keystroke("s", :command)
     subject.save
   end
   
-  it "Should be able to save as a file" do
+  it "Should be able to save as a file without duplicate being available" do
+    subject.should_receive(:duplicate_available?).and_return(false)
     save_dialog = double("Osaka::TypicalSaveDialog")
     subject.should_receive(:save_dialog).and_return(save_dialog)
     save_dialog.should_receive(:save).with("filename")
-    subject.wrapper.should_receive(:set_current_window).with("filename")
+    expect_set_current_window("filename")
     subject.save_as("filename")
   end
+
+  it "Should be able to save as a file using the duplicate..." do
+    new_instance = mock(:TypicalApplication)
+    new_instance_wrapper = mock(:ApplicationWrapper)
+    save_dialog = double("Osaka::TypicalSaveDialog").as_null_object
+
+    subject.should_receive(:duplicate_available?).and_return(true)
+    subject.should_receive(:duplicate).and_return(new_instance)
+    new_instance.should_receive(:wrapper).and_return(new_instance_wrapper)
+    new_instance_wrapper.should_receive(:clone).and_return(@wrapper)
+    
+    subject.should_receive(:close)
+    subject.should_receive(:save_dialog).and_return(save_dialog)
+    expect_set_current_window("filename")
+    subject.save_as("filename")    
+  end
+  
+  it "Should be able to check whether Duplicate is supported" do
+    expect_exists(at.menu_item("Duplicate").menu(1).menu_bar_item("File").menu_bar(1)).and_return(true)
+    subject.duplicate_available?.should == true
+  end
+  
+  it "Should throw an exception when duplicate is not available"do
+    subject.should_receive(:duplicate_available?).and_return(false)
+    lambda {subject.duplicate}.should raise_error(Osaka::VersioningError, "MacOS Versioning Error: Duplicate is not available on this Mac version")
+  end
+  
+  it "Should return a new keynote instance variable after duplication" do
+    new_instance = mock(:TypicalApplication)
+    subject.should_receive(:duplicate_available?).and_return(true)
+    subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("duplicate window", "New name duplicate window")
+    expect_keystroke("s", [:command, :shift])  
+    subject.should_receive(:clone).and_return(new_instance)
+    new_instance.should_receive(:wrapper).and_return(@wrapper)
+    expect_keystroke!(:return)
+    expect_set_current_window("New name duplicate window")
+    subject.duplicate.should == new_instance
+  end
   
   it "Should be able to close" do
     expect_keystroke("w", :command)
@@ -103,12 +141,12 @@ describe "Osaka::TypicalApplication" do
   end
   
   it "Should be able to activate" do
-    @wrapper.should_receive(:activate)
+    expect_activate
     subject.activate
   end
   
   it "Should be able to focus" do
-    @wrapper.should_receive(:focus)
+    expect_focus
     subject.focus
   end
   
@@ -134,19 +172,32 @@ describe "Osaka::TypicalApplication" do
   
   it "Should be able to retrieve a print dialog" do
     expect_keystroke("p", :command)
-    should_wait_until(:exists, at.sheet(1))
+    expect_wait_until_exists(at.sheet(1))
     subject.print_dialog
   end
   
-  it "Should be able to retrieve a save dialog" do
+  it "Should be able to check whether the save will pop up a dialog or not" do
+    expect_exists(at.menu_item("Save…").menu(1).menu_bar_item("File").menu_bar(1)).and_return(true)
+    subject.save_pops_up_dialog?.should == true
+  end
+  
+  it "Should be able to retrieve a save dialog by using save as" do
+    subject.should_receive(:save_pops_up_dialog?).and_return(false)
     expect_keystroke("s", [:command, :shift])
-    should_wait_until(:exists, at.sheet(1))
+    expect_wait_until_exists(at.sheet(1))
     subject.save_dialog    
   end
   
+  it "Should be able to retrieve a save dialog using duplicate and save" do
+    subject.should_receive(:save_pops_up_dialog?).and_return(true)
+    subject.should_receive(:save)
+    expect_wait_until_exists(at.sheet(1))
+    subject.save_dialog
+  end
+  
   describe "Application info" do
     it "Should be able to retrieve an application info object and parse it" do
-      @wrapper.should_receive(:tell).with('get info for (path to application "ApplicationName")').and_return('name:ApplicationName.app, creation date:date "Sunday, December 21, 2008 PM 06:14:11"}')
+      expect_tell('get info for (path to application "ApplicationName")').and_return('name:ApplicationName.app, creation date:date "Sunday, December 21, 2008 PM 06:14:11"}')
       app_info = subject.get_info
       app_info.name.should == "ApplicationName.app"
     end
@@ -160,17 +211,17 @@ describe "Osaka::TypicalApplication" do
       save_dialog_mock = double(:GenericSaveDialog)
       
       expect_click!(at.menu_button("PDF").sheet(1)) 
-      should_wait_until!(:exists, at.menu(1).menu_button("PDF").sheet(1))
+      expect_wait_until_exists!(at.menu(1).menu_button("PDF").sheet(1))
       
       expect_click!(at.menu_item(2).menu(1).menu_button("PDF").sheet(1))
-      should_wait_until!(:exists, at.window("Save"))
+      expect_wait_until_exists!(at.window("Save"), at.sheet(1).window("Print")).and_return(at.window("Save"))
 
       subject.should_receive(:create_save_dialog).with(at.window("Save"), subject.wrapper).and_return(save_dialog_mock)
       save_dialog_mock.should_receive(:save).with("filename")
       
-      should_do_until!(:not_exists, at.sheet(1)) {
-        expect_click!(at.checkbox(1).window("Print"))
-      }
+      expect_until_not_exists!(at.sheet(1))
+      expect_exists(at.checkbox(1).sheet(1)).and_return(true)
+      expect_click!(at.checkbox(1).sheet(1))
       
       subject.save_as_pdf("filename")
     end
@@ -202,7 +253,7 @@ describe "Osaka::TypicalApplication" do
     end
     
     it "Should set the path when a full path is given" do
-      subject.wrapper.as_null_object
+      @wrapper.as_null_object
       subject.should_receive(:set_filename)
       subject.should_receive(:set_folder).with("/path/second")
       subject.save("/path/second/name")
@@ -210,21 +261,21 @@ describe "Osaka::TypicalApplication" do
     
     it "Should be able to click save" do
       expect_click(at.button("Save").sheet(1))
-      should_wait_until(:not_exists, at.sheet(1))
+      expect_wait_until_not_exists(at.sheet(1))
       subject.click_save
     end
     
     it "Should be able to set the filename" do
-      subject.wrapper.should_receive(:set).with('value', at.text_field(1).sheet(1), "filename")
+      @wrapper.should_receive(:set).with('value', at.text_field(1).sheet(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,  at.sheet(1).sheet(1))
-      subject.wrapper.should_receive(:set).with("value", at.text_field(1).sheet(1).sheet(1), "path")
+      expect_wait_until_exists(at.sheet(1).sheet(1))
+      expect_set("value", at.text_field(1).sheet(1).sheet(1), "path")
       expect_click(at.button("Go").sheet(1).sheet(1))
-      should_wait_until(:not_exists, at.sheet(1).sheet(1))
+      expect_wait_until_not_exists(at.sheet(1).sheet(1))
       subject.set_folder("path")
     end
   end

metadata

@@ -2,7 +2,7 @@
 name: osaka
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Bas Vodde
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-23 00:00:00 +08:00
+date: 2012-08-07 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency