osaka 0.4.8 → 0.4.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 854d5b4239636f0440e333079786058eb04104d5
+  data.tar.gz: 05d82bb53d115828c0545585288c1d5c155097ff
+SHA512:
+  metadata.gz: 98ac0bf615f682f2fe15913e42c4785bff36a0635e46745a43fc4c4d6329f1e5d3529ed7539727a4e8c69f2f31ef888f5f109926ea9b9ddf26e3f5e167b948ce
+  data.tar.gz: abb76f7009b18c85e62847f563a3aa6384e4ebfa742d24396dbeee73de36c7fd6cb140adca7d7c90e0622a059d354e28949361e7e8382067ad25f9bbd62b6188

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rspec', '~> 3.1'
+end

data/README.rdoc

@@ -1,6 +1,6 @@
 
 Osaka - apple OSA script Kontrolling the Application (OSAKA :P)
-This is a Ruby 1.9 library for automating work via GUI on Mac (using OSA/Applescript)
+This is a Ruby library for automating work via GUI on Mac (using OSA/Applescript)
 
 = How to install
 

data/Rakefile

@@ -1,6 +1,16 @@
 #!/usr/bin/env rake
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:spec)
+task :default => :all
 
-task :default => :spec
+desc "Run the spec tasks"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["--tag ~integration"]
+end
+
+desc "Run the integration tests"
+RSpec::Core::RakeTask.new(:integration) do |t|
+  t.rspec_opts = ["--tag integration"]
+end
+  
+RSpec::Core::RakeTask.new(:all)

data/lib/osaka.rb

@@ -1,5 +1,11 @@
 
+# Non UI servies
+require 'osaka/commandrunner'
 require 'osaka/scriptrunner'
+require 'osaka/launchservices'
+require 'osaka/defaultssystem'
+
+# Basic UI automation
 require 'osaka/location'
 require 'osaka/remotecontrol'
 require 'osaka/typicalapplication'

data/lib/osaka/calculator.rb

@@ -31,4 +31,4 @@ module Osaka
       control.get!('value', at.static_text(1).group(1))
     end
   end
-end
+end

data/lib/osaka/commandrunner.rb

@@ -0,0 +1,17 @@
+
+# encoding: utf-8
+
+module Osaka
+
+  class SystemCommandFailed < RuntimeError
+  end
+
+  module CommandRunner
+    def self.run(command)
+      output = `#{command} 2>&1`
+      raise Osaka::SystemCommandFailed, "message" + output unless $?.success?
+      output
+    end
+  end
+end
+    

data/lib/osaka/defaultssystem.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+class DefaultsSystem
+  
+  
+  def initialize(domain)
+    @domain = domain
+    @settings = {}
+    parse_settings_file(Osaka::CommandRunner.run("defaults read #{domain}"))
+  end
+  
+  def parse_settings_file (settings_from_defaults)    
+    scanner = StringScanner.new (settings_from_defaults)
+    scanner.scan(/{\n/)
+    while scanner.scan(/\s+(.*) = (.*);\n/) do
+      @settings[scanner[1]] = scanner[2]
+    end
+  end
+  
+  def [](key)
+    @settings[key]
+  end
+  
+  def []=(key, value)
+    Osaka::CommandRunner.run("defaults write #{@domain} #{key} #{value}")
+  end
+  
+end

data/lib/osaka/keynote.rb

@@ -16,12 +16,14 @@ module Osaka
     end
     
     def select_all_slides
-      if control.exists?(at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1))
-        control.click(at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1))
-      else
-        control.click(at.button("Slides").group(1).outline(1).scroll_area(1).splitter_group(1).splitter_group(1))
-      end
+      light_table_view
       select_all
     end
+
+    def light_table_view
+      if control.exists?(at.menu_item("Light Table").menu(1).menu_bar_item("View").menu_bar(1))
+        control.click(at.menu_item("Light Table").menu(1).menu_bar_item("View").menu_bar(1))
+      end
+    end
   end
-end
+end

data/lib/osaka/keynoteflow.rb

@@ -1,22 +1,29 @@
 
 module CommonFlows
+    
   def self.keynote_combine_files(result_file, files_to_merge)
     keynote = Osaka::Keynote.new
+    keynote.activate
+    keynote.raise_error_on_open_standard_windows("All Keynote windows must be closed before running this flow")
+        
     files_to_merge = [files_to_merge].flatten
     keynote.open(files_to_merge.shift)
+    keynote.light_table_view
     keynote.save_as(result_file)
     
+    
     files_to_merge.each { |file|
       combine_keynote = Osaka::Keynote.new
       combine_keynote.open(file)
       combine_keynote.select_all_slides
       combine_keynote.copy
+      combine_keynote.close
       keynote.select_all_slides
       keynote.paste
-      combine_keynote.close
     }
     
     keynote.save
+    keynote.close
     keynote.quit
   end
   
@@ -26,4 +33,5 @@ module CommonFlows
     files_to_open = files_in_directory.collect { |f| File.join(directory, f)}
     keynote_combine_files(result_file, files_to_open.sort)
   end
-end
+   
+end

data/lib/osaka/launchservices.rb

@@ -0,0 +1,29 @@
+
+module Osaka
+  module LaunchServices
+
+    def self.dump
+      Osaka::CommandRunner.run("/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump")
+    end
+
+    def self.retrieve(bundle_name)
+      launch_services_dump = Osaka::CommandRunner.run("/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump")
+      current_hash = {}
+      launch_services_hash = {}
+
+      launch_services_dump.each_line do |line|
+        if line =~ /^(\w.*):\s+(\w.*)$/
+          launch_services_hash[current_hash[:name]] = current_hash
+          current_hash = {:id => $2}
+        end
+        if line =~ /^\t(\w.*):\s+(\w.*)$/
+          current_hash[$1.to_sym] = $2
+          #puts current_hash
+        end
+      end
+      launch_services_hash[current_hash[:name]] = current_hash
+      launch_services_hash[bundle_name]
+    end
+
+  end
+end

data/lib/osaka/location.rb

@@ -153,4 +153,4 @@ end
 
 def at
   Osaka::Location.new ""
-end
+end

data/lib/osaka/mailmergeflow.rb

@@ -16,4 +16,4 @@ module CommonFlows
     pages.close(:dont_save)
     pages.quit(:dont_save)
   end
-end
+end

data/lib/osaka/numbers.rb

@@ -50,4 +50,4 @@ module Osaka
     
     
   end
-end
+end

data/lib/osaka/osakaexpectations.rb

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

data/lib/osaka/pages.rb

@@ -1,9 +1,9 @@
 
 module Osaka
-  
+
   class PagesError < RuntimeError
   end
-  
+
   class PagesMailMergeDialog
     attr_accessor :control, :location
 
@@ -11,30 +11,30 @@ module Osaka
       @location = location
       @control = control
     end
-  
+
     def merge
       control.click!(at.button("Merge").sheet(1))
       print_dialog_location = at.window("Print")
       control.wait_until_exists!(at.menu_button("PDF") + print_dialog_location)
       TypicalPrintDialog.new(control.name, print_dialog_location)
     end
-        
+
     def set_merge_to_new_document
       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)
       control.click(at.pop_up_button(2).sheet(1))
       control.wait_until_exists!(at.menu_item(value).menu(1).pop_up_button(2).sheet(1))
       control.click!(at.menu_item(value).menu(1).pop_up_button(2).sheet(1))
-    end    
+    end
   end
-  
+
   class PagesInspector
     attr_accessor :control
     attr_accessor :location_symbol_map
@@ -52,41 +52,50 @@ module Osaka
       @location_symbol_map[:chart] = 8
       @location_symbol_map[:link] = 9
       @location_symbol_map[:quicktime] = 10
-    end    
-    
+    end
+
     def get_location_from_symbol(inspector_name)
       at.radio_button(@location_symbol_map[inspector_name]).radio_group(1)
     end
-    
+
     def select_inspector(inspector)
       control.click(get_location_from_symbol(inspector))
       control.wait_until_exists(at.window(inspector.to_s))
       control.set_current_window(inspector.to_s)
     end
-    
+
     def change_mail_merge_source
       select_inspector(:link)
       control.click(at.radio_button(3).tab_group(1).group(1)).wait_until_exists(at.button("Choose...").tab_group(1).group(1))
-      control.click(at.button("Choose...").tab_group(1).group(1))        
+      control.click(at.button("Choose...").tab_group(1).group(1))
     end
-    
+
   end
 
   class Pages < TypicalApplication
-  
+
     def initialize
       super "Pages"
     end
-    
+
     def type(text)
       control.keystroke(text)
     end
-  
+
     def self.create_document(filename, &block)
-      numbers = Osaka::Pages.new
-      numbers.create_document(filename, &block)
+      pages = Osaka::Pages.new
+      pages.create_document(filename, &block)
+    end
+
+    def new_document
+      super
+      if control.current_window_name == "Template Chooser"
+        control.set_current_window(do_and_wait_for_new_window {
+          control.click(at.button("Choose").window("Template Chooser"))
+        })
+      end
     end
-  
+
     def set_mail_merge_document(filename)
       inspector.change_mail_merge_source
       control.wait_until_exists(at.sheet(1))
@@ -97,19 +106,19 @@ module Osaka
       if (control.exists?(at.sheet(1).sheet(1)))
         raise(PagesError, "Setting Mail Merge numbers file failed")
       end
-      control.click(at.button("OK").sheet(1))      
+      control.click(at.button("OK").sheet(1))
     end
-        
+
     def mail_merge_field(field_name)
       control.click_menu_bar(at.menu_item(field_name).menu(1).menu_item("Merge Field"), "Insert")
     end
-    
+
     def mail_merge
       control.click_menu_bar(at.menu_item(20), "Edit")
       control.wait_until_exists(at.button("Merge").sheet(1))
       PagesMailMergeDialog.new(at.sheet(1), control)
     end
-    
+
     def mail_merge_to_pdf(filename)
       mail_merge_dialog = mail_merge
       mail_merge_dialog.set_merge_to_printer
@@ -128,6 +137,6 @@ module Osaka
       }
       PagesInspector.new(control.name, at.window(window_name))
     end
-  
+
   end
-end
+end