osaka 0.4.8 → 0.4.10

data/spec/launchservices_spec.rb

@@ -0,0 +1,63 @@
+require 'osaka'
+
+describe "Launch Services (wrapper around lsregister)" do
+
+  before (:each) do
+    @dumped_registry = <<-END_OF_DUMP
+Checking data integrity......done.
+Status: Database is seeded.
+Status: Preferences are loaded.
+--------------------------------------------------------------------------------
+bundle	id:            54064
+	path:          /Applications/TextMate.app
+	name:          TextMate
+	category:
+	identifier:    com.macromates.TextMate.preview (0x8005c399)
+	canonical id:  com.macromates.textmate.preview (0x8005c38f)
+	version:       9515.0
+	mod date:      2/24/2014 14:57:26
+	reg date:      3/7/2014 13:22:06
+	type code:     'APPL'
+	creator code:  'avin'
+	sys version:   10.7
+	exec sdk ver:  10.8
+	exec os ver:   10.7
+	flags:         relative-icon-path  wildcard
+	item flags:    container  package  application  extension-hidden  native-app  scriptable  x86_64
+	hi res:        is-capabile  user-can-change
+	app nap:       is-capabile  user-can-change
+	icon:          Contents/Resources/TextMate.icns
+	executable:    Contents/MacOS/TextMate
+	inode:         32052233
+	exec inode:    53967831
+	container id:  32
+	library:       Contents/Library/
+	library items: QuickLook/TextMateQL.qlgenerator/
+	               ../PlugIns/Dialog.tmplugin/
+	               ../PlugIns/Dialog2.tmplugin/
+	--------------------------------------------------------
+	type	id:            62684
+		bindableKey:   91052
+		generation:    20451
+		uti:           com.macromates.textmate.snippet
+		description:   TextMate Snippet
+		flags:         exported  active  trusted
+		icon:          Contents/Resources/TextMate Snippet.icns
+		conforms to:   com.apple.property-list
+		tags:          .tmsnippet
+END_OF_DUMP
+  end
+
+  it "Can return a dump of the current database" do
+   expect(Osaka::CommandRunner).to receive(:run).with("/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump").and_return(@dumped_registry)
+   current_dump = Osaka::LaunchServices.dump
+   expect(current_dump).to start_with("Checking data integrity......done.\nStatus: Database is seeded.\nStatus: Preferences are loaded.\n--------------------------------------------------------------------------------")
+   expect(current_dump).to include("name:          TextMate")
+  end
+
+  it "Can retrieve a value based on the bundle name" do
+    Osaka::CommandRunner.should_receive(:run).and_return(@dumped_registry)
+    Osaka::LaunchServices.retrieve("TextMate")[:id].should== "54064"
+  end
+end
+

data/spec/location_spec.rb

@@ -5,47 +5,47 @@ describe "Location path for an applescript command" do
   
   it "Should be able to create a valid location when appending two locations" do
     location = Osaka::Location.new("scrollbar") + Osaka::Location.new("window 1")
-    location.to_s.should == "scrollbar of window 1"
+    expect(location.to_s).to eq "scrollbar of window 1"
   end
   
   it "Should be able to add empty locations" do
     location = Osaka::Location.new("location") + ""
-    location.to_s.should == "location"
+    expect(location.to_s).to eq "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")
+    expect(location.top_level_element).to eq at.window("three")
   end
   
   
   it "Should be able to create locations using at" do
-    at.button(1).to_s.should == "button 1"
+    expect(at.button(1).to_s).to eq "button 1"
   end
   
   it "Should be able to create empty prefixed locations" do
-    Osaka::Location.new("").as_prefixed_location.should == ""
+    expect(Osaka::Location.new("").as_prefixed_location).to eq ""
   end
   
   it "Should be able to check whether the location already has a window" do
-    Osaka::Location.new("").has_window?.should == false
-    at.window("one").has_window?.should == true
+    expect(Osaka::Location.new("").has_window?).to eq false
+    expect(at.window("one").has_window?).to eq true
   end
   
   it "Should be able to create groups" do
-    at.group(1).to_s.should == "group 1"
+    expect(at.group(1).to_s).to eq "group 1"
   end
   
   it "Should be able to combine buttons with groups" do
-    at.button("1").group(2).to_s.should == 'button "1" of group 2'
+    expect(at.button("1").group(2).to_s).to eq 'button "1" of group 2'
   end
   
   it "Should be able to combine groups with windows" do
-    at.button(1).group(2).window("Name").to_s.should == 'button 1 of group 2 of window "Name"'
+    expect(at.button(1).group(2).window("Name").to_s).to eq 'button 1 of group 2 of window "Name"'
   end
   
   it "Can compare different locations" do
-    at.button(1).should == at.button(1)
+    expect(at.button(1)).to eq at.button(1)
   end
   
   it "Should be able to convert to a prefixed location" do
@@ -53,7 +53,7 @@ describe "Location path for an applescript command" do
   end
   
   it "Cannot create a location with two times window" do
-    lambda {at.window(1).window(1)}.should raise_error(Osaka::InvalidLocation, "Invalid location: window 1 of window 1")
+    expect(lambda {at.window(1).window(1)}).to raise_error(Osaka::InvalidLocation, "Invalid location: window 1 of window 1")
   end
 
-end
+end

data/spec/mailmergeflow_spec.rb

@@ -3,21 +3,21 @@ require "osaka"
 
 describe "Mail Merge to PDF common flow" do
 
-  let(:mock_numbers) { mock("Number")}
-  let(:mock_pages) { mock("Pages") }
+  let(:mock_numbers) { double("Number")}
+  let(:mock_pages) { double("Pages") }
 
   it "Should do a good mail merge with Pages and Keynote flow" do
     
-    Osaka::Numbers.should_receive(:create_document).with("/template/numbers").and_yield(mock_numbers)
+    expect(Osaka::Numbers).to receive(:create_document).with("/template/numbers").and_yield(mock_numbers)
     
-    Osaka::Pages.should_receive(:new).and_return(mock_pages)
+    expect(Osaka::Pages).to receive(:new).and_return(mock_pages)
     
-    mock_pages.should_receive(:open).with("/template/pages")
-    mock_pages.should_receive(:set_mail_merge_document).with("/template/numbers")
-    mock_pages.should_receive(:mail_merge_to_pdf).with("/output/file.pdf")
+    expect(mock_pages).to receive(:open).with("/template/pages")
+    expect(mock_pages).to receive(:set_mail_merge_document).with("/template/numbers")
+    expect(mock_pages).to receive(:mail_merge_to_pdf).with("/output/file.pdf")
     
-    mock_pages.should_receive(:close).with(:dont_save)    
-    mock_pages.should_receive(:quit).with(:dont_save)
+    expect(mock_pages).to receive(:close).with(:dont_save)    
+    expect(mock_pages).to receive(:quit).with(:dont_save)
     
     CommonFlows.number_and_pages_mail_merge("/template/numbers", "/template/pages", "/output/file.pdf") {}
   end
@@ -25,14 +25,14 @@ describe "Mail Merge to PDF common flow" do
   it "Should yield for filling in the numbers fields" do
     mock_numbers.as_null_object
     mock_pages.as_null_object
-    Osaka::Numbers.should_receive(:create_document).and_yield(mock_numbers)
-    Osaka::Pages.should_receive(:new).and_return(mock_pages)
+    expect(Osaka::Numbers).to receive(:create_document).and_yield(mock_numbers)
+    expect(Osaka::Pages).to receive(:new).and_return(mock_pages)
 
     retrieved_numbers = nil
     CommonFlows.number_and_pages_mail_merge("1", "2", "3") { |numbers|
       retrieved_numbers = numbers
     }    
-    retrieved_numbers.should == mock_numbers
+    expect(retrieved_numbers).to eq mock_numbers
   end
   
-end
+end

data/spec/numbers_spec.rb

@@ -6,11 +6,11 @@ describe "Osaka::Numbers" do
   include(*Osaka::OsakaExpectations)
 
   subject { Osaka::Numbers.new }  
-  let(:control) { subject.control = mock("RemoteControl").as_null_object}
+  let(:control) { subject.control = double("RemoteControl").as_null_object}
   
   it "Should be able to get the column count" do
     expect_tell('tell document 1; tell sheet 1; tell table 1; get column count; end tell; end tell; end tell').and_return("10")
-    subject.column_count.should == 10
+    expect(subject.column_count).to eq 10
   end
   
   it "Should be able to set the column count to a certain value" do
@@ -19,14 +19,14 @@ describe "Osaka::Numbers" do
   end
   
   it "Should be able to fill in data in cells" do 
-    subject.should_receive(:column_count).and_return(10)
+    expect(subject).to receive(:column_count).and_return(10)
     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
   
   it "Will change the column count when the cell is outside of the range of the current column count" do
-    subject.should_receive(:column_count).and_return(5)
-    subject.should_receive(:set_column_count).with(6)
+    expect(subject).to receive(:column_count).and_return(5)
+    expect(subject).to receive(:set_column_count).with(6)
     expect_tell('tell document 1; tell sheet 1; tell table 1; set value of cell 6 of row 2 to "30"; end tell; end tell; end tell')
     subject.fill_cell(6, 2, "30")
     
@@ -34,9 +34,9 @@ describe "Osaka::Numbers" do
   
   it "Should be able to select blank from the template choser" do
     expect_set_current_window("Template Choser")
-    subject.should_receive(:do_and_wait_for_new_window).and_return("Template Choser")
+    expect(subject).to receive(:do_and_wait_for_new_window).and_return("Template Choser")
     expect_set_current_window("Untitled")
-    subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("Untitled")
+    expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("Untitled")
     expect_keystroke(:return)
     subject.new_document 
   end
@@ -47,11 +47,11 @@ describe "Osaka::Numbers" do
   end
   
   it "Should be able to use a class method for creating documents quickly" do
-      Osaka::Numbers.should_receive(:new).any_number_of_times.and_return(mock("App"))
-      subject.should_receive(:create_document)
+      expect(Osaka::Numbers).to receive(:new).at_least(1).times.and_return(double("App"))
+      expect(subject).to receive(:create_document)
 
       Osaka::Numbers.create_document("filename") { |doc|
       }    
   end
     
-end
+end

data/spec/osakaexpectations_spec.rb

@@ -5,7 +5,7 @@ describe "Osakas Ruby expectations" do
 
   include(*Osaka::OsakaExpectations)
 
-  subject { mock("RemoteControl") }
+  subject { double("RemoteControl") }
   let(:control) { subject }
   
   it "Wait until exists can be called without a code block" do
@@ -20,7 +20,7 @@ describe "Osakas Ruby expectations" do
     subject.wait_until_exists!(at.window(1)) {
       code_block_been_called = true
     }
-    code_block_been_called.should be_true
+    expect(code_block_been_called).to be true
   end
 
-end
+end

data/spec/pages_spec.rb

@@ -6,48 +6,67 @@ describe "Osaka::Pages" do
   include(*Osaka::OsakaExpectations)
 
   subject { Osaka::Pages.new }
-  
-  let (:control) { subject.control = mock("Remote Control", :name => "ApplicationName")}
-  
+
+  let (:control) { subject.control = double("Remote Control", :name => "ApplicationName")}
+
   context "Basic document operations" do
-    
+
     it "Should be able to type in the file" do
       expect_keystroke("Hello")
       subject.type("Hello")
-    end  
+    end
+
+    it "Should be able to create a new document using template choser if there is one" do
+      expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("Template Chooser")    
+      expect_keystroke("n", :command)
+      expect_set_current_window("Template Chooser")
+      expect_focus      
+      expect_current_window_name.and_return("Template Chooser")   
+      expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("New Document")
+      expect_click(at.button("Choose").window("Template Chooser"))
+      expect_set_current_window("New Document")
+      subject.new_document
+    end
+
+    it "Should be able to create a new document also when there is no template chooser" do
+      expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("New Document")    
+      expect_keystroke("n", :command)
+      expect_set_current_window("New Document")
+      expect_focus
+      expect_current_window_name.and_return("New Document")
+      subject.new_document
+    end
+
   end
-  
+
   it "Should be able to use a class method for creating documents quickly" do
-      Osaka::Pages.should_receive(:new).any_number_of_times.and_return(mock("App"))
-      subject.should_receive(:create_document)
+      expect(Osaka::Pages).to receive(:new).at_least(1).times.and_return(double("App"))
+      expect(subject).to receive(:create_document)
 
       Osaka::Pages.create_document("filename") { |doc|
-      }    
+      }
   end
-    
+
   it "Should be able to do mail merge to a PDF flow" do
     
-    mail_merge_dialog = mock("Pages Mail Merge Dialog")
-    print_dialog = mock("Generic Print Dialog")
+    mail_merge_dialog = double("Pages Mail Merge Dialog")
+    print_dialog = double("Generic Print Dialog")
     
-    subject.should_receive(:mail_merge).and_return(mail_merge_dialog)
-    mail_merge_dialog.should_receive(:merge).and_return(print_dialog)
-    mail_merge_dialog.should_receive(:set_merge_to_printer)
-    print_dialog.should_receive(:save_as_pdf).with("filename")
+    expect(subject).to receive(:mail_merge).and_return(mail_merge_dialog)
+    expect(mail_merge_dialog).to receive(:merge).and_return(print_dialog)
+    expect(mail_merge_dialog).to receive(:set_merge_to_printer)
+    expect(print_dialog).to receive(:save_as_pdf).with("filename")
     
     subject.mail_merge_to_pdf("filename")
   end
-    
+
   it "Should be able to select the Mail Merge" do
-    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
-    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))
 
@@ -55,54 +74,54 @@ describe "Osaka::Pages" do
     expect_wait_until_exists!(at.menu_button("PDF").window("Print"))
     subject.mail_merge.merge
   end
-  
+
   it "Should be able to get an inspector object" do
-    subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("Link")
+    expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("Link")
     expect_exists?(at.menu_item("Show Inspector").menu(1).menu_bar_item("View").menu_bar(1)).and_return(true)
     expect_click_menu_bar(at.menu_item("Show Inspector"), "View")
     
-    inspector_mock = mock("Inspector")
-    Osaka::PagesInspector.should_receive(:new).with(control.name, at.window("Link")).and_return(inspector_mock)    
-    subject.inspector.should equal(inspector_mock)
+    inspector_mock = double("Inspector")
+    expect(Osaka::PagesInspector).to receive(:new).with(control.name, at.window("Link")).and_return(inspector_mock)    
+    expect(subject.inspector).to eq(inspector_mock)
   end
-  
+
   it "Should be able to get the inspector object also when it is already visible" do
-    subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("Link")
+    expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("Link")
     expect_exists?(at.menu_item("Show Inspector").menu(1).menu_bar_item("View").menu_bar(1)).and_return(false)
     expect_click_menu_bar(at.menu_item("Hide Inspector"), "View")
     expect_wait_until_exists(at.menu_item("Show Inspector").menu(1).menu_bar_item("View").menu_bar(1))
     expect_click_menu_bar(at.menu_item("Show Inspector"), "View")
     subject.inspector
   end
-  
+
   it "Should be able to change the mail merge document source" do
-    inspector_mock = mock("Inspector")
-    subject.should_receive(:inspector).and_return(inspector_mock)
-    inspector_mock.should_receive(:change_mail_merge_source)
+    inspector_mock = double("Inspector")
+    expect(subject).to receive(:inspector).and_return(inspector_mock)
+    expect(inspector_mock).to receive(:change_mail_merge_source)
     
     expect_wait_until_exists(at.sheet(1))
-    subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("dialog")
+    expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("dialog")
     expect_click(at.radio_button("Numbers Document:").radio_group(1).sheet(1))
     
-    subject.should_receive(:select_file_from_open_dialog).with("/tmp/filename", at.window("dialog"))
+    expect(subject).to receive(:select_file_from_open_dialog).with("/tmp/filename", at.window("dialog"))
     expect_click(at.button("OK").sheet(1))
-    
+
     expect_exists?(at.sheet(1).sheet(1)).and_return(false)
     subject.set_mail_merge_document("/tmp/filename")
   end
-  
+
   it "Should be able to stop when an error happens due to mail merge. This is especially important since otherwise Pages goes nuts and crashes :)" do
-    subject.should_receive(:inspector).and_return(mock("Inspector").as_null_object)    
+    expect(subject).to receive(:inspector).and_return(double("Inspector").as_null_object)    
     expect_wait_until_exists(at.sheet(1))
-    subject.should_receive(:do_and_wait_for_new_window)
-    subject.should_receive(:select_file_from_open_dialog)
+    expect(subject).to receive(:do_and_wait_for_new_window)
+    expect(subject).to receive(:select_file_from_open_dialog)
     
     expect_exists?(at.sheet(1).sheet(1)).and_return(true)
-        
+
     expect {subject.set_mail_merge_document("/tmp/filename") }.to raise_error(Osaka::PagesError, "Setting Mail Merge numbers file failed")
-    
+
   end
-  
+
   it "Should be able to insert a merge field" do
     expect_click_menu_bar(at.menu_item("Data").menu(1).menu_item("Merge Field"), "Insert")
     subject.mail_merge_field("Data")
@@ -110,36 +129,36 @@ describe "Osaka::Pages" do
 end
 
 describe "Osaka::Pages Inspector" do
-  
+
   include(*Osaka::OsakaExpectations)
 
   subject {Osaka::PagesInspector.new("Pages", "Link")}
-  let(:control) {subject.control = mock("RemoteControl")}
+  let(:control) {subject.control = double("RemoteControl")}
   
   it "Can convert symbolic names to locations" do
     # Nice... checking a map. Perhaps delete ?
-    subject.get_location_from_symbol(:document).should == at.radio_button(1).radio_group(1)
-    subject.get_location_from_symbol(:layout).should == at.radio_button(2).radio_group(1)
-    subject.get_location_from_symbol(:wrap).should == at.radio_button(3).radio_group(1)
-    subject.get_location_from_symbol(:text).should == at.radio_button(4).radio_group(1)
-    subject.get_location_from_symbol(:graphic).should == at.radio_button(5).radio_group(1)
-    subject.get_location_from_symbol(:metrics).should == at.radio_button(6).radio_group(1)
-    subject.get_location_from_symbol(:table).should == at.radio_button(7).radio_group(1)
-    subject.get_location_from_symbol(:chart).should == at.radio_button(8).radio_group(1)
-    subject.get_location_from_symbol(:link).should == at.radio_button(9).radio_group(1)
-    subject.get_location_from_symbol(:quicktime).should == at.radio_button(10).radio_group(1)
+    expect(subject.get_location_from_symbol(:document)).to eq at.radio_button(1).radio_group(1)
+    expect(subject.get_location_from_symbol(:layout)).to eq at.radio_button(2).radio_group(1)
+    expect(subject.get_location_from_symbol(:wrap)).to eq at.radio_button(3).radio_group(1)
+    expect(subject.get_location_from_symbol(:text)).to eq at.radio_button(4).radio_group(1)
+    expect(subject.get_location_from_symbol(:graphic)).to eq at.radio_button(5).radio_group(1)
+    expect(subject.get_location_from_symbol(:metrics)).to eq at.radio_button(6).radio_group(1)
+    expect(subject.get_location_from_symbol(:table)).to eq at.radio_button(7).radio_group(1)
+    expect(subject.get_location_from_symbol(:chart)).to eq at.radio_button(8).radio_group(1)
+    expect(subject.get_location_from_symbol(:link)).to eq at.radio_button(9).radio_group(1)
+    expect(subject.get_location_from_symbol(:quicktime)).to eq at.radio_button(10).radio_group(1)
   end
-  
-  
+
+
   it "Should be able to select the different inspectors" do
     expect_click(subject.get_location_from_symbol(:document))
     expect_wait_until_exists(at.window("document"))
     expect_set_current_window("document")
     subject.select_inspector(:document)
   end
-  
+
   it "Change the mail merge source" do
-    subject.should_receive(:select_inspector).with(:link)
+    expect(subject).to receive(:select_inspector).with(:link)
     expect_click(at.radio_button(3).tab_group(1).group(1))
     expect_wait_until_exists(at.button("Choose...").tab_group(1).group(1))
     expect_click(at.button("Choose...").tab_group(1).group(1))
@@ -149,11 +168,11 @@ describe "Osaka::Pages Inspector" do
 end
 
 describe "Osaka::Pages Mail Merge dialog" do
-  
+
   include(*Osaka::OsakaExpectations)
 
   subject { Osaka::PagesMailMergeDialog.new("", nil) }
-  let(:control) {subject.control = mock("RemoteControl").as_null_object}
+  let(:control) {subject.control = double("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))
@@ -161,12 +180,12 @@ describe "Osaka::Pages Mail Merge dialog" do
     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))
     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    
+    subject.set_merge_to_printer
   end
 end