osaka 0.3.2 → 0.4.0

data/lib/osaka/typicalapplication.rb

@@ -1,104 +1,43 @@
 # encoding: utf-8
 module Osaka
   
-  class TypicalSaveDialog
-    attr_accessor :wrapper
-
-    def initialize(self_location, wrapper)
-      @self_location = self_location
-      @wrapper = wrapper.clone
-      @wrapper.set_current_window("") if self_location.has_top_level_element?
-    end
-  
-    def set_filename(filename)
-      @wrapper.set("value", at.text_field(1) + @self_location, filename)
-    end
-  
-    def set_folder(pathname)
-      @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)
-    end
-  
-    def click_save
-      @wrapper.click(at.button("Save") + @self_location).wait_until_not_exists(@self_location)
-    end
-  
-    def save(filename)
-      set_filename(File.basename(filename))
-      set_folder(File.dirname(filename))  unless File.dirname(filename) == "."
-      click_save
-    end
-
-  end  
-
-  class TypicalPrintDialog
-    attr_accessor :wrapper
-
-    def initialize(parent, wrapper)
-      @parent = parent
-      @wrapper = wrapper
-    end
-  
-    def create_save_dialog(location, app)
-      TypicalSaveDialog.new(location, app)
-    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)
-      
-      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) {
-        # 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!
-        # This is for snow leopard
-        @wrapper.click!(at.checkbox(1) + @parent) if @wrapper.exists(at.checkbox(1) + @parent)
-      }
-    end
-  end
-  
   class ApplicationInfo
 
     attr_reader :name
 
     def initialize(script_info)
       @name = script_info.match(/name:(.+?), creation date/)[1]
-    end
-    
+    end    
   end
 
   class TypicalApplication
   
-    attr_accessor :wrapper
+    attr_accessor :control
   
     def initialize(name)
       @name = name
-      @wrapper = ApplicationWrapper.new(name)
+      @control = RemoteControl.new(name)
     end
     
     def initialize_copy(other)
       super
-      @wrapper = other.wrapper.clone
+      @control = other.control.clone
     end
     
     def get_info
-      script_info = @wrapper.tell("get info for (path to application \"#{@name}\")")
+      script_info = control.tell("get info for (path to application \"#{@name}\")")
       ApplicationInfo.new(script_info)
     end
   
     def open (filename)
       abolutePathFileName = File.absolute_path(filename)
-      @wrapper.tell("open \"#{abolutePathFileName}\"")
-      @wrapper.set_current_window(File.basename(filename))
+      control.tell("open \"#{abolutePathFileName}\"")
+      control.set_current_window(File.basename(filename))
     end
 
     def wait_for_window_and_dialogs_to_close(option)
       if (option != :user_chose)
-        @wrapper.until_not_exists!(@wrapper.current_window_location) {
+        control.until_not_exists!(control.base_location) {
           close_dialog_sheet_with_dont_save
         }
       end
@@ -106,44 +45,44 @@ module Osaka
 
     def wait_for_application_to_quit(option)
       if (option != :user_chose)
-        while @wrapper.running?
+        while control.running?
           close_dialog_sheet_with_dont_save
         end
       end
     end
     
     def close_dialog_sheet_with_dont_save
-      if (@wrapper.exists(at.sheet(1)))
-        @wrapper.click!(at.button("Don’t Save").sheet(1))
+      if (control.exists?(at.sheet(1)))
+        control.click!(at.button("Don’t Save").sheet(1))
       end
     end
     
     def quit(option = :user_chose)
-      if @wrapper.running?
-        @wrapper.quit
+      if control.running?
+        control.quit
         wait_for_application_to_quit(option)
       end
     end
 
     def do_and_wait_for_new_window
-      @wrapper.activate
-      latest_window_list = original_window_list = @wrapper.window_list
+      control.activate
+      latest_window_list = original_window_list = control.window_list
       yield
       while (original_window_list == latest_window_list)
-        latest_window_list = @wrapper.window_list
+        latest_window_list = control.window_list
       end
       (latest_window_list - original_window_list)[0]
     end
     
     def new_document
-      @wrapper.set_current_window(do_and_wait_for_new_window {
-        @wrapper.keystroke("n", :command)
+      control.set_current_window(do_and_wait_for_new_window {
+        control.keystroke("n", :command)
       })
-      @wrapper.focus
+      control.focus
     end
     
     def duplicate_available?
-      @wrapper.exists(at.menu_item("Duplicate").menu(1).menu_bar_item("File").menu_bar(1))
+      control.exists?(at.menu_item("Duplicate").menu(1).menu_bar_item("File").menu_bar(1))
     end
     
     def duplicate
@@ -151,90 +90,93 @@ module Osaka
         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])
+        control.click_menu_bar(at.menu_item("Duplicate"), "File")
       }
       new_instance = clone
-      new_instance.wrapper.set_current_window(do_and_wait_for_new_window {
+      new_instance.control.set_current_window(do_and_wait_for_new_window {
         sleep(0.4) # This sleep is added because mountain lion keynote crashes without it!
-        @wrapper.keystroke!(:return)
-      })
+        control.keystroke!(:return)
+      }) unless control.mac_version == :lion
       
       new_instance
     end
     
     def save
-      @wrapper.keystroke("s", :command)
+      control.keystroke("s", :command)
     end
     
     def save_pops_up_dialog?
-      @wrapper.exists(at.menu_item("Save…").menu(1).menu_bar_item("File").menu_bar(1))
+      control.exists?(at.menu_item("Save…").menu(1).menu_bar_item("File").menu_bar(1))
     end
     
     def save_dialog
       if save_pops_up_dialog?
         save
-        @wrapper.wait_until_exists(at.sheet(1))
+        control.wait_until_exists(at.sheet(1))
       else
-        @wrapper.keystroke("s", [:command, :shift]).wait_until_exists(at.sheet(1))
+        control.keystroke("s", [:command, :shift]).wait_until_exists(at.sheet(1))
       end
-      create_save_dialog(at.sheet(1))
+      create_save_dialog(at.sheet(1) + control.base_location)
     end
     
     def save_as(filename)
       if duplicate_available?
-        new_instance = duplicate
-        close
-        @wrapper = new_instance.wrapper.clone
-      end
+        new_instance = duplicate        
+        close        
+        @control = new_instance.control.clone
+      end      
       dialog = save_dialog
       dialog.save(filename)
-      @wrapper.set_current_window(File.basename(filename))
+      control.set_current_window(File.basename(filename))
     end
     
     def close(option = :user_chose)
-      @wrapper.keystroke("w", :command)
+      control.keystroke("w", :command)
       wait_for_window_and_dialogs_to_close(option)
     end
   
     def activate
-      @wrapper.activate
+      if (control.mac_version == :lion)
+        control.launch unless control.running? 
+      end
+      control.activate
     end
     
     def focus
-      @wrapper.focus
+      control.focus
     end
     
     def running?
-      @wrapper.running?
+      control.running?
     end
   
     def copy
-      @wrapper.keystroke("c", :command)
+      control.keystroke("c", :command)
     end
 
     def paste
-      @wrapper.keystroke("v", :command)
+      control.keystroke("v", :command)
     end
 
     def cut
-      @wrapper.keystroke("x", :command)
+      control.keystroke("x", :command)
     end
 
     def select_all
-      @wrapper.keystroke("a", :command)
+      control.keystroke("a", :command)
     end
     
     def create_print_dialog(location)
-      TypicalPrintDialog.new(location, @wrapper)
+      TypicalPrintDialog.new(control.name, location)
     end
     
     def create_save_dialog(location)
-      TypicalSaveDialog.new(location, @wrapper)
+      TypicalSaveDialog.new(control.name, location)
     end
   
     def print_dialog
-      @wrapper.keystroke("p", :command).wait_until_exists(at.sheet(1))
-      create_print_dialog(at.sheet(1))
+      control.keystroke("p", :command).wait_until_exists(at.sheet(1))
+      create_print_dialog(at.sheet(1) + control.base_location)
     end
   
   end

data/lib/osaka/typicalprintdialog.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Osaka
+  
+  class TypicalPrintDialog
+    attr_accessor :control
+
+    def initialize(application_name, own_location)
+      @control = Osaka::RemoteControl.new(application_name, own_location)
+    end
+  
+    def create_save_dialog(application_name, own_location)
+      TypicalSaveDialog.new(application_name, own_location)
+    end
+
+    def save_as_pdf(filename)
+      control.click!(at.menu_button("PDF")).wait_until_exists!(at.menu(1).menu_button("PDF"))
+      control.click!(at.menu_item(2).menu(1).menu_button("PDF"))
+      
+      save_location = control.wait_until_exists!(at.window("Save"), at.sheet(1) + control.base_location)
+      save_dialog = create_save_dialog(control.name, save_location)
+      save_dialog.save(filename)
+      
+      control.until_not_exists!(control.base_location) {
+        # 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!
+        # This is for snow leopard
+        control.click!(at.checkbox(1)) if control.exists?(at.checkbox(1))
+      }
+    end
+  end
+  
+end

data/lib/osaka/typicalsavedialog.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Osaka
+  
+  class TypicalSaveDialog
+    attr_accessor :control
+
+    def initialize(application_name, own_location)
+      @control = Osaka::RemoteControl.new(application_name, own_location)
+    end
+  
+    def set_filename(filename)
+      control.set("value", at.text_field(1), filename)
+    end
+  
+    def set_folder(pathname)
+      control.keystroke("g", [ :command, :shift ]).wait_until_exists(at.sheet(1))
+      control.set("value", at.text_field(1).sheet(1), pathname)
+      control.click(at.button("Go").sheet(1)).wait_until_not_exists(at.sheet(1))
+    end
+  
+    def click_save
+      control.click(at.button("Save")).wait_until_not_exists(control.base_location)
+    end
+  
+    def save(filename)
+      set_filename(File.basename(filename))
+      set_folder(File.dirname(filename))  unless File.dirname(filename) == "."
+      click_save
+    end
+
+  end  
+
+end

data/lib/osaka/version.rb

@@ -1,4 +1,4 @@
 
 module Osaka
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/lib/osaka.rb

@@ -1,9 +1,10 @@
 
 require 'osaka/scriptrunner'
 require 'osaka/location'
-require 'osaka/applicationwrapper'
-require 'osaka/applicationwrapperexpectations'
+require 'osaka/remotecontrol'
 require 'osaka/typicalapplication'
+require 'osaka/typicalsavedialog'
+require 'osaka/typicalprintdialog'
 require 'osaka/pages'
 require 'osaka/numbers'
 require 'osaka/keynote'
@@ -11,4 +12,5 @@ require 'osaka/calculator'
 require 'osaka/textedit'
 require 'osaka/mailmergeflow'
 require 'osaka/keynoteflow'
+require 'osaka/osakaexpectations'
 

data/spec/calculator_spec.rb

@@ -3,20 +3,18 @@ require 'osaka'
 
 describe "Mac GUI Calculator" do
 
-  include(*Osaka::ApplicationWrapperExpectations)
+  include(*Osaka::OsakaExpectations)
 
   subject { Osaka::Calculator.new }
-  let(:wrapper) { subject.wrapper = double("Osaka::ApplicationWrapper")}
+  let(:control) { subject.control = mock("RemoteControl", :mac_version => :mountain_lion)}
 
   it "Should be setting the window when starting the Calculator" do
-    
-    # TODO: Fix this duplication between this and TextEdit.
-    
-    wrapper.should_receive(:activate)
-    wrapper.should_receive(:current_window_name).and_return("")
+        
+    expect_activate
+    expect_current_window_name.and_return("")
     subject.should_receive(:wait_for_new_window).with([])
-    wrapper.should_receive(:window_list).and_return(["Calculator"])
-    wrapper.should_receive(:set_current_window).with("Calculator")
+    expect_window_list.and_return(["Calculator"])
+    expect_set_current_window("Calculator")
     subject.activate
   end
     
@@ -31,14 +29,14 @@ describe "Mac GUI Calculator" do
   end
   
   it "Should be able to quit the calculator" 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 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")
+    expect_get!("value", at.static_text(1).group(1)).and_return("0")
     subject.result.should == "0"
   end
   

data/spec/integration_keynote_spec.rb

@@ -4,6 +4,7 @@ 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/keynote_flows_spec.rb

@@ -3,7 +3,7 @@ require "osaka"
 
 describe "Common flows in keynote" do
 
-  let(:mock_keynote) { double(:Keynote)}
+  let(:mock_keynote) { mock("First keynote")}
 
   it "Should be able to combine just one single file" do
     Osaka::Keynote.should_receive(:new).and_return(mock_keynote)
@@ -15,8 +15,8 @@ describe "Common flows in keynote" do
   end
   
   it "Should be able to combine multiple files in one result" do
-    mock2_keynote = double(:Keynote)
-    mock3_keynote = double(:Keynote)
+    mock2_keynote = mock("Second keynote")
+    mock3_keynote = mock("Third keynote")
     Osaka::Keynote.should_receive(:new).and_return(mock_keynote, mock2_keynote, mock3_keynote)  
     mock_keynote.should_receive(:open).with("one_file.key")
     mock_keynote.should_receive(:save_as).with("result.key")
@@ -50,7 +50,7 @@ describe "Common flows in keynote" do
   it "Should be able to combine multiple files from one directory sorted with pattern" do
     files_in_dir = [".", "..", "05_file.key", "02key.wrong", "another", "01hey.key", "last"]
     files_in_dir_to_be_used = ["dirname/01hey.key", "dirname/05_file.key"]
-    mocked_dir = double(:Dir)
+    mocked_dir = mock("Directory with keynote files")
     Dir.should_receive(:new).with("dirname").and_return(mocked_dir)
     mocked_dir.should_receive(:entries).and_return(files_in_dir)
     CommonFlows.should_receive(:keynote_combine_files).with("results.key", files_in_dir_to_be_used)

data/spec/keynote_spec.rb

@@ -3,10 +3,10 @@ require 'osaka'
 
 describe "Osaka::Keynote" do
 
-  include(*Osaka::ApplicationWrapperExpectations)
+  include(*Osaka::OsakaExpectations)
 
   subject { Osaka::Keynote.new }
-  let(:wrapper) {subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object}
+  let(:control) {subject.control = mock("RemoteControl").as_null_object}
   
   it "Should create the correct keynote print dialog" do
     subject.create_print_dialog("window").should be_instance_of Osaka::KeynotePrintDialog
@@ -14,7 +14,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)    
-    expect_exists(slides_button_location).and_return(true)
+    expect_exists?(slides_button_location).and_return(true)
     expect_click(slides_button_location)
     subject.should_receive(:select_all)
     subject.select_all_slides
@@ -23,7 +23,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)
-    expect_exists(slides_button_location).and_return(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/location_spec.rb

@@ -13,6 +13,12 @@ describe "Location path for an applescript command" do
     location.to_s.should == "location"
   end
   
+  it "Should be able to get the top-level element out" do
+    location = at.sheet(1).sheet(2).window("three")
+    location.top_level_element.should == at.window("three")
+  end
+  
+  
   it "Should be able to create locations using at" do
     at.button(1).to_s.should == "button 1"
   end

data/spec/mailmergeflow_spec.rb

@@ -3,8 +3,8 @@ require "osaka"
 
 describe "Mail Merge to PDF common flow" do
 
-  let(:mock_numbers) { double(:Numbers)}
-  let(:mock_pages) { double(:Pages) }
+  let(:mock_numbers) { mock("Number")}
+  let(:mock_pages) { mock("Pages") }
 
   it "Should do a good mail merge with Pages and Keynote flow" do
     Osaka::Numbers.should_receive(:new).and_return(mock_numbers)

data/spec/numbers_spec.rb

@@ -3,13 +3,12 @@ require 'osaka'
 
 describe "Osaka::Numbers" do
 
-  include(*Osaka::ApplicationWrapperExpectations)
+  include(*Osaka::OsakaExpectations)
 
   subject { Osaka::Numbers.new }  
-  let(:wrapper) { subject.wrapper = double("Osaka::Number").as_null_object}
+  let(:control) { subject.control = mock("RemoteControl").as_null_object}
   
   it "Should be able to fill in data in cells" do
-    # subject.wrapper.should_receive(:tell).with('tell document 1; tell sheet 1; tell table 1; set value of cell 1 of row 2 to "30"; end tell; end tell; end tell')
     expect_tell('tell document 1; tell sheet 1; tell table 1; set value of cell 1 of row 2 to "30"; end tell; end tell; end tell')
     subject.fill_cell(1, 2, "30")
   end

data/spec/osakaexpectations_spec.rb

@@ -0,0 +1,26 @@
+
+require 'osaka'
+
+describe "Osakas Ruby expectations" do
+
+  include(*Osaka::OsakaExpectations)
+
+  subject { mock("RemoteControl") }
+  let(:control) { subject }
+  
+  it "Wait until exists can be called without a code block" do
+    expect_wait_until_exists!(at.window(1))
+    subject.wait_until_exists!(at.window(1))
+  end
+
+  it "Wait until exists can be called with a code block" do
+    code_block_been_called = false
+    expect_wait_until_exists!(at.window(1)).and_yield
+    
+    subject.wait_until_exists!(at.window(1)) {
+      code_block_been_called = true
+    }
+    code_block_been_called.should be_true
+  end
+
+end

data/spec/pages_spec.rb

@@ -3,16 +3,16 @@ require 'osaka'
 
 describe "Osaka::Pages" do
 
-  include(*Osaka::ApplicationWrapperExpectations)
+  include(*Osaka::OsakaExpectations)
 
   subject { Osaka::Pages.new }
   
-  let (:wrapper) { subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object}
+  let (:control) { subject.control = mock("Remote Control").as_null_object}
   
   it "Should be able to do mail merge to a PDF flow" do
     
-    mail_merge_dialog = double(:PagesMailMergeDialog)
-    print_dialog = double(:GenericPrintDialog)
+    mail_merge_dialog = mock("Pages Mail Merge Dialog")
+    print_dialog = mock("Generic Print Dialog")
     
     subject.should_receive(:mail_merge).and_return(mail_merge_dialog)
     mail_merge_dialog.should_receive(:merge).and_return(print_dialog)
@@ -23,14 +23,14 @@ describe "Osaka::Pages" do
   end
     
   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_current_window_name.any_number_of_times.and_return("Pages.pages")
     expect_click_menu_bar(at.menu_item(20), "Edit")
     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_current_window_name.any_number_of_times.and_return("Pages.pages")
     expect_click!(at.button("Merge").sheet(1))
     expect_wait_until_exists!(at.menu_button("PDF").window("Print"))
     subject.mail_merge.merge
@@ -39,10 +39,10 @@ end
 
 describe "Osaka::Pages Mail Merge dialog" do
   
-  include(*Osaka::ApplicationWrapperExpectations)
+  include(*Osaka::OsakaExpectations)
 
   subject { Osaka::PagesMailMergeDialog.new("", nil) }
-  let(:wrapper) {subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object}
+  let(:control) {subject.control = mock("RemoteControl").as_null_object}
   
   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))