osaka 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/osaka/applicationwrapper.rb

@@ -0,0 +1,112 @@
+
+module Osaka
+  
+  class ApplicationWrapper
+  
+    def initialize(name)
+      @name = name
+    end
+  
+    def activate
+      tell("activate")
+    end
+  
+    def quit
+      tell("quit")
+    end
+  
+    def tell(command)
+      ScriptRunner::execute("tell application \"#{@name}\"; #{command}; end tell")
+    end
+  
+    def system_event!(event)
+      ScriptRunner::execute("tell application \"System Events\"; tell process \"#{@name}\"; #{event}; end tell; end tell")
+    end
+
+    def system_event(event)
+      activate
+      system_event!(event)
+    end
+    
+    def wait_until_exists!(element_to_wait_for)
+      system_event!("repeat until exists #{element_to_wait_for}; end repeat")
+    end
+
+    def wait_until_exists(element_to_wait_for)
+      activate
+      wait_until_exists!(element_to_wait_for)
+    end
+    
+    def wait_until_not_exists!(element_to_wait_for)
+      system_event!("repeat until not exists #{element_to_wait_for}; end repeat")
+    end
+
+    def wait_until_not_exists(element_to_wait_for)
+      activate
+      wait_until_not_exists!(element_to_wait_for)
+    end
+    
+    def construct_modifier_statement(modifier_keys)
+      modified_key_string = [ modifier_keys ].flatten.collect! { |mod_key| mod_key.to_s + " down"}.join(", ")
+      modifier_command = " using {#{modified_key_string}}" unless modifier_keys.empty?
+      modifier_command
+    end
+    
+    def keystroke!(key, modifier_keys = [])
+      system_event!("keystroke \"#{key}\"#{construct_modifier_statement(modifier_keys)}")
+    end
+    
+    def keystroke(key, modifier_keys = [])
+      activate
+      keystroke!(key, modifier_keys)
+    end
+        
+    def keystroke_and_wait_until_exists!(key, modifier_keys, element)
+      keystroke!(key, modifier_keys)
+      wait_until_exists!(element)
+    end
+
+    def keystroke_and_wait_until_exists(key, modifier_keys, element)
+      activate
+      keystroke_and_wait_until_exists!(key, modifier_keys, element)
+    end
+  
+    def click!(element)
+      system_event!("click #{element}")
+    end
+
+    def click(element)
+      activate
+      click!(element)
+    end
+  
+    def click_and_wait_until_exists!(element, wait_condition)
+      click!(element)
+      wait_until_exists!(wait_condition)
+    end
+
+    def click_and_wait_until_exists(element, wait_condition)
+      activate
+      click_and_wait_until_exists!(element, wait_condition)
+    end
+  
+    def click_and_wait_until_not_exists!(element, wait_condition)
+      click!(element)
+      wait_until_not_exists!(wait_condition)
+    end
+
+    def click_and_wait_until_not_exists(element, wait_condition)
+      activate
+      click_and_wait_until_not_exists!(element, wait_condition)
+    end
+      
+    def set!(element, value)
+      system_event!("set #{element} to \"#{value}\"")
+    end
+
+    def set(element, value)
+      activate
+      set!(element, value)
+    end
+  end
+end

data/lib/osaka/keynote.rb

@@ -0,0 +1,18 @@
+
+module Osaka
+  
+  class KeynotePrintDialog < TypicalPrintDialog
+  
+  end
+
+  class Keynote < TypicalApplication  
+  
+    def initialize
+      super "Keynote"
+    end
+
+    def create_print_dialog(location)
+      KeynotePrintDialog.new(location, app)
+    end
+  end
+end

data/lib/osaka/numbers.rb

@@ -0,0 +1,13 @@
+
+module Osaka
+  class Numbers < TypicalApplication
+  
+    def initialize
+      super "Numbers"
+    end
+  
+    def fill_cell(row, column, value)
+      @wrapper.tell("tell document 1; tell sheet 1; tell table 1; set value of cell #{column} of row #{row} to \"#{value}\"; end tell; end tell; end tell")
+    end
+  end
+end

data/lib/osaka/pages.rb

@@ -0,0 +1,38 @@
+
+module Osaka
+  class PagesMailMergeDialog
+    attr_accessor :wrapper
+
+    def initialize(wrapper)
+      @wrapper = wrapper
+    end
+  
+    def merge
+      @wrapper.click!('button "Merge" of sheet 1 of window 1')
+      print_dialog_location = 'window "Print"' 
+      @wrapper.wait_until_exists!("menu button \"PDF\" of #{print_dialog_location}")
+      TypicalPrintDialog.new(print_dialog_location, @wrapper)
+    end
+  
+  end
+
+  class Pages < TypicalApplication
+  
+    def initialize
+      super "Pages"
+    end
+  
+    def mail_merge
+      @wrapper.systemEvent("tell menu bar 1; tell menu \"Edit\"; click menu item 20; end tell; end tell")
+      @wrapper.wait_until_exists('button "Merge" of sheet 1 of window 1')
+      PagesMailMergeDialog.new(@wrapper)
+    end
+    
+    def mail_merge_to_pdf(filename)
+      mail_merge_dialog = mail_merge
+      print_dialog = mail_merge_dialog.merge
+      print_dialog.save_as_pdf(filename)
+    end
+  
+  end
+end

data/lib/osaka/scriptrunner.rb

@@ -0,0 +1,38 @@
+
+module Osaka
+  
+  class ScriptRunnerError < RuntimeError
+  end
+
+  module ScriptRunner
+
+    @@debug_info_enabled = false
+
+    def self.enabled_debug_prints
+      @@debug_info_enabled = true
+    end
+
+    def self.disable_debug_prints
+      @@debug_info_enabled = false
+    end
+
+    def self.debug_prints?
+      @@debug_info_enabled
+    end
+  
+    def self.execute(applescript)
+      script_commands = applescript.gsub('"', '\\"').split(';')
+      escaped_commands = "" 
+      script_commands.each { |l| 
+        escaped_commands += " -e \"#{l.strip}\""
+      }
+      puts "Executing: osascript#{escaped_commands}" if debug_prints?
+      
+      raise(Osaka::ScriptRunnerError, "Error received while executing: #{applescript}") unless system("osascript#{escaped_commands}")
+    end  
+  
+    def self.execute_file(scriptName, parameters = "")
+      system("osascript #{scriptName} #{parameters}".strip)
+    end
+  end
+end

data/lib/osaka/typicalapplication.rb

@@ -0,0 +1,91 @@
+
+module Osaka
+  
+  class TypicalSaveDialog
+    attr_accessor :wrapper
+
+    def initialize(location, wrapper)
+      @location = location
+      @wrapper = wrapper
+    end
+  
+    def set_filename(filename)
+      @wrapper.set("value of text field 1 of #{@location}", filename)
+    end
+  
+    def set_folder(pathname)
+      @wrapper.keystroke_and_wait_until_exists("g", [ :command, :shift ], "sheet 1 of #{@location}")
+      @wrapper.set("value of text field 1 of sheet 1 of #{@location}", pathname)
+      @wrapper.click_and_wait_until_not_exists("button \"Go\" of sheet 1 of #{@location}", "sheet 1 of #{@location}")
+    end
+  
+    def click_save
+      @wrapper.click_and_wait_until_not_exists("button \"Save\"  of #{@location}", "#{@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(location, wrapper)
+      @location = location
+      @wrapper = wrapper
+    end
+  
+    def create_save_dialog(location, app)
+      GenericSaveDialog.new(location, app)
+    end
+
+    def save_as_pdf(filename)
+      @wrapper.click_and_wait_until_exists!("menu button \"PDF\" of #{@location}", "menu 1 of menu button \"PDF\" of #{@location}")
+      @wrapper.click_and_wait_until_exists!("menu item 2 of menu 1 of menu button \"PDF\" of #{@location}", 'window "Save"')
+      save_dialog = create_save_dialog("window \"Save\"", @wrapper)
+      save_dialog.save(filename)
+      @wrapper.wait_until_not_exists(@location)
+    end
+  end
+
+  class TypicalApplication
+  
+    attr_accessor :wrapper
+  
+    def initialize(name)
+      @wrapper = ApplicationWrapper.new(name)
+    end
+  
+    def open (filename)
+      abolutePathFileName = File.absolute_path(filename)
+      @wrapper.tell("open \"#{abolutePathFileName}\"")
+    end
+  
+    def quit
+      @wrapper.quit
+    end
+
+    def save
+      @wrapper.keystroke("s", :command)
+    end
+  
+    def activate
+      @wrapper.activate
+    end
+  
+    def create_print_dialog(location)
+      TypicalPrintDialog.new(location, @wrapper)
+    end
+  
+    def print_dialog
+      location = "sheet 1 of window 1"
+      @wrapper.keystroke_and_wait_until_exists("p", :command, location)
+      create_print_dialog(location)
+    end
+  
+  end
+end

data/lib/osaka/version.rb

@@ -0,0 +1,4 @@
+
+module Osaka
+  VERSION = "0.1.0"
+end

data/lib/osaka.rb

@@ -0,0 +1,7 @@
+
+require 'osaka/scriptrunner'
+require 'osaka/applicationwrapper'
+require 'osaka/typicalapplication'
+require 'osaka/pages'
+require 'osaka/numbers'
+require 'osaka/keynote'

data/osaka.gemfile

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require File.expand_path('../lib/osaka/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name    = 'osaka'
+  gem.version = Osaka::VERSION
+  gem.date    = Date.today.to_s
+
+  gem.summary = "Osaka is an Mac GUI automation library"
+  gem.description = "Osaka wraps osascript (Applescript) and provides a ruby interface for automating tasks through the GUI on Mac"
+
+  gem.authors  = ['Bas Vodde']
+  gem.email    = 'basv@odd-e.com'
+  gem.homepage = 'https://github.com/basvodde/osaka'
+
+  gem.add_dependency('rake')
+  gem.add_development_dependency('rspec', [">= 2.0.0"])
+
+  gem.files = `git ls-files -- {.,test,spec,lib}/*`.split("\n")
+end

data/spec/applicationwrapper_spec.rb

@@ -0,0 +1,144 @@
+
+require 'osaka'
+
+describe "Osaka::ApplicationWrapper" do
+
+  name = "ApplicationName"
+  quoted_name = "\"#{name}\""
+  subject { Osaka::ApplicationWrapper.new(name) }
+  
+  it "Should be able to tell applications to do something" do
+    Osaka::ScriptRunner.should_receive(:execute).with("tell application #{quoted_name}; command; end tell")
+    subject.tell("command")
+  end
+
+  it "Can also pass multi-line commands to telling an application what to do" do
+    Osaka::ScriptRunner.should_receive(:execute).with("tell application #{quoted_name}; activate; quit; end tell")
+    subject.tell("activate; quit")
+  end
+
+  it "Has a short-cut method for activation" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/activate/)
+    subject.activate
+  end
+  
+  it "Has a short-cut method for quitting" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/quit/)
+    subject.quit
+  end
+    
+  it "Should be able to generate events via the Systems Events" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/tell application "System Events"; tell process #{quoted_name}; quit; end tell; end tell/)
+    subject.system_event!("quit")
+  end
+
+  it "Should be able to generate events via the Systems Events and activate the application first" do
+    subject.should_receive(:activate)
+    subject.should_receive(:system_event!).with("quit")
+    subject.system_event("quit")
+  end
+  
+  it "Should be able to wait for for a specific element existing" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until exists window 1; end repeat/)
+    subject.wait_until_exists!("window 1")
+  end
+  
+  it "Should be able to wait until exists and activate the application first" do
+    subject.should_receive(:activate)
+    subject.should_receive(:wait_until_exists!).with("window 1")
+    subject.wait_until_exists("window 1")    
+  end
+
+  it "Should be able to wait for a specific element to not exist anymore" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/repeat until not exists window 1; end repeat/)
+    subject.wait_until_not_exists!("window 1")    
+  end
+  
+  it "Should be able to wait_until_not_exists and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:wait_until_not_exists!).with("window 1")
+    subject.wait_until_not_exists("window 1")        
+  end
+  
+  it "Should be able to generate keystroke events" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/)
+    subject.keystroke!("p")
+  end
+  
+  it "Should be able to keystroke and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:keystroke!).with("a", [])
+    subject.keystroke("a", [])        
+  end
+  
+  it "Should be able to do keystrokes with command down" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p" using {command down}/)
+    subject.keystroke!("p", :command)    
+  end
+
+  it "Should be able to do keystrokes with option and command down" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p" using {option down, command down}/)
+    subject.keystroke!("p", [ :option, :command ])    
+  end
+  
+  it "Should be able to do a keystroke and wait until something happen in one easy command" do
+    subject.should_receive(:keystroke!).with("p", [])
+    subject.should_receive(:wait_until_exists!).with("window 1")
+    subject.keystroke_and_wait_until_exists!("p", [], "window 1")
+  end
+  
+  it "Should be able to keystroke_and_wait_until_exists and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:keystroke_and_wait_until_exists!).with("p", [], "window 1")
+    subject.keystroke_and_wait_until_exists("p", [], "window 1")    
+  end
+  
+  it "Should be able to do clicks" do
+    Osaka::ScriptRunner.should_receive(:execute).with(/click menu button "PDF"/)
+    subject.click!('menu button "PDF"')
+  end
+  
+  it "Should be able to do click and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:click!).with("button")
+    subject.click("button")    
+  end
+  
+  it "Should be able to do clicks and wait until something happened in one easy command" do
+    subject.should_receive(:click!).with("button")
+    subject.should_receive(:wait_until_exists!).with("window")
+    subject.click_and_wait_until_exists!("button", "window")
+  end
+  
+  it "Should be able to click_and_wait_until_exists and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:click_and_wait_until_exists!).with("button", "window")
+    subject.click_and_wait_until_exists("button", "window")
+  end
+    
+  it "Should be able to click and wait until something doesn't exist anymore" do
+    subject.should_receive(:click!).with("button1")
+    subject.should_receive(:wait_until_not_exists!).with("window 1")
+    subject.click_and_wait_until_not_exists!('button1', 'window 1')
+  end
+
+  it "Should be able to click_and_wait_until_not_exists and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:click_and_wait_until_not_exists!).with("button", "window")
+    subject.click_and_wait_until_not_exists('button', 'window')    
+  end
+  
+  it "Should be able to set a value to an element" do
+    subject.should_receive(:system_event!).with(/set value of window to "newvalue"/)
+    subject.set!("value of window", "newvalue")
+  end
+  
+  it "Should be able to set a value and activate" do
+    subject.should_receive(:activate)
+    subject.should_receive(:set!).with("value of window", "newvalue")
+    subject.set("value of window", "newvalue")
+  end
+  
+  
+  
+end

data/spec/keynote_spec.rb

@@ -0,0 +1,11 @@
+
+require 'osaka'
+
+describe "Osaka::Keynote" do
+
+  subject { Osaka::Keynote.new }
+  
+  before (:each) do
+    subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object
+  end
+end

data/spec/numbers_spec.rb

@@ -0,0 +1,17 @@
+
+require 'osaka'
+
+describe "Osaka::Numbers" do
+
+  subject { Osaka::Numbers.new }
+  
+  before (:each) do
+    subject.wrapper = double("Osaka::Number").as_null_object
+  end
+  
+  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 2 of row 1 to "30"; end tell; end tell; end tell')
+    subject.fill_cell(1, 2, "30")
+  end
+  
+end

data/spec/pages_spec.rb

@@ -0,0 +1,37 @@
+
+require 'osaka'
+
+describe "Osaka::Pages" do
+
+  subject { Osaka::Pages.new }
+  
+  before (:each) do
+    subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object
+  end
+  
+  it "Should be able to do mail merge to a PDF flow" do
+    
+    mail_merge_dialog = double(:PagesMailMergeDialog)
+    print_dialog = double(:GenericPrintDialog)
+    
+    subject.should_receive(:mail_merge).and_return(mail_merge_dialog)
+    mail_merge_dialog.should_receive(:merge).and_return(print_dialog)
+    print_dialog.should_receive(:save_as_pdf).with("filename")
+    
+    subject.mail_merge_to_pdf("filename")
+    
+  end
+  
+  it "Should be able to select the Mail Merge" do
+    subject.wrapper.should_receive(:systemEvent).with("tell menu bar 1; tell menu \"Edit\"; click menu item 20; end tell; end tell")
+    subject.wrapper.should_receive(:wait_until_exists).with('button "Merge" of sheet 1 of window 1')
+    subject.mail_merge
+  end
+
+  it "Should click the merge button of the mail merge dialog" do
+    subject.wrapper.should_receive(:click!).with('button "Merge" of sheet 1 of window 1')
+    subject.wrapper.should_receive(:wait_until_exists!).with('menu button "PDF" of window "Print"')
+    subject.mail_merge.merge
+  end
+  
+end

data/spec/scriptrunner_spec.rb

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

data/spec/typicalapplication_spec.rb

@@ -0,0 +1,95 @@
+
+require 'osaka'
+
+describe "Osaka::TypicalApplication" do
+
+  subject { Osaka::TypicalApplication.new("ApplicationName") }
+  
+  before (:each) do
+    subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object
+  end
+  
+  it "Should pass the right open string to the Keynote application osascript" do
+    filename = "filename.key"
+    subject.wrapper.should_receive(:tell).with("open \"#{File.absolute_path(filename)}\"")
+    subject.open(filename)    
+  end
+  
+  it "Should be able to quit" do
+    subject.wrapper.should_receive(:quit)
+    subject.quit
+  end
+  
+  it "Should be able to save" do
+    subject.wrapper.should_receive(:keystroke).with("s", :command)
+    subject.save
+  end
+  
+  it "Should be able to activate keynote" do
+    subject.wrapper.should_receive(:activate)
+    subject.activate
+  end
+  
+  it "Should be able to retrieve a print dialog" do
+    subject.wrapper.should_receive(:keystroke_and_wait_until_exists).with("p", :command, "sheet 1 of window 1")
+    subject.print_dialog
+  end
+  
+  describe "Generic Print Dialog" do
+    
+    location = "window 1"
+    subject { Osaka::TypicalPrintDialog.new("window 1", double(:OSAApp).as_null_object) }
+
+    it "Should be able to save the PDF in a print dialog" do
+      save_dialog_mock = double(:GenericSaveDialog)
+      subject.wrapper.should_receive(:click_and_wait_until_exists!).with('menu button "PDF" of window 1', 'menu 1 of menu button "PDF" of window 1')
+      subject.wrapper.should_receive(:click_and_wait_until_exists!).with('menu item 2 of menu 1 of menu button "PDF" of window 1', 'window "Save"')
+      subject.should_receive(:create_save_dialog).with("window \"Save\"", subject.wrapper).and_return(save_dialog_mock)
+      save_dialog_mock.should_receive(:save).with("filename")
+      subject.wrapper.should_receive(:wait_until_not_exists).with('window 1')
+      subject.save_as_pdf("filename")
+    end
+  end
+  
+  describe "Generic Save Dialog" do
+    
+    subject { Osaka::TypicalSaveDialog.new("window 1", double("Osaka::ApplicationWrapper").as_null_object)}
+    
+    it "Should set the filename in the test field" do
+      subject.should_receive(:set_filename).with("filename")
+      subject.should_receive(:click_save)
+      subject.should_not_receive(:set_folder)
+      subject.save("filename")
+    end
+    
+    it "Should pick only the base filename when a path is given" do
+      subject.should_receive(:set_filename).with("filename")
+      subject.should_receive(:set_folder)
+      subject.should_receive(:click_save)
+      subject.save("/path/filename")
+    end
+    
+    it "Should set the path when a full path is given" do
+      subject.should_receive(:set_filename)
+      subject.should_receive(:set_folder).with("/path/second")
+      subject.save("/path/second/name")
+    end
+    
+    it "Should be able to click save" do
+      subject.wrapper.should_receive(:click_and_wait_until_not_exists).with('button "Save"  of window 1', 'window 1')
+      subject.click_save
+    end
+    
+    it "Should be able to set the filename" do
+      subject.wrapper.should_receive(:set).with('value of text field 1 of window 1', "filename")
+      subject.set_filename("filename")
+    end
+    
+    it "Should be able to set the path" do
+      subject.wrapper.should_receive(:keystroke_and_wait_until_exists).with("g", [ :command, :shift ], "sheet 1 of window 1")
+      subject.wrapper.should_receive(:set).with("value of text field 1 of sheet 1 of window 1", "path")
+      subject.wrapper.should_receive(:click_and_wait_until_not_exists).with('button "Go" of sheet 1 of window 1', "sheet 1 of window 1")
+      subject.set_folder("path")
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: osaka
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Bas Vodde
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-10 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+  type: :development
+  version_requirements: *id002
+description: Osaka wraps osascript (Applescript) and provides a ruby interface for automating tasks through the GUI on Mac
+email: basv@odd-e.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- lib/osaka.rb
+- lib/osaka/applicationwrapper.rb
+- lib/osaka/keynote.rb
+- lib/osaka/numbers.rb
+- lib/osaka/pages.rb
+- lib/osaka/scriptrunner.rb
+- lib/osaka/typicalapplication.rb
+- lib/osaka/version.rb
+- osaka.gemfile
+- spec/applicationwrapper_spec.rb
+- spec/keynote_spec.rb
+- spec/numbers_spec.rb
+- spec/pages_spec.rb
+- spec/scriptrunner_spec.rb
+- spec/typicalapplication_spec.rb
+has_rdoc: true
+homepage: https://github.com/basvodde/osaka
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Osaka is an Mac GUI automation library
+test_files: []
+