coderifous-tornado 0.0.1

data/README.markdown

@@ -0,0 +1,93 @@
+Tornado
+=======
+
+Tornado is a ruby gem that let's you write ruby scripts that looks like this:
+
+    tell OSX do
+      hide_everything
+    end
+
+    tell Terminal do
+      open_new_tab("~/dev/web_site")
+
+      open_new_tab(DEV_DIR) do
+        tail "~/dev/web_site/log/*.log"
+      end
+  
+      open_new_tab("~/dev/web_site") do
+        run "autotest"
+      end
+    end
+    
+    tell Textmate do
+      minimize_all_windows
+      open DEV_DIR
+      resize 400, "100%"
+      reposition :east
+    end
+
+    tell Firefox do
+      open_new_tab("http://web-site.local")
+    end
+
+Documentation
+-------------
+
+None yet - this thing is new.
+
+Why
+-----
+
+Tornado sits on top of Appscript, which is an Apple event bridge.
+Appscript is GREAT, I wanted something even higher level.  Something
+that would just let me easily do the common things I want to do when 
+switching between projects: open terminals, run commands, open the
+project in my text editor, minimize/hide other apps, etc.
+
+See below for code comparisons:
+
+Using Appscript directly:
+-------------------------
+
+    # hide all apps
+
+    se = Appscript.app("System Events")
+    se.keystroke("h", :using => [ :command_down, :option_down ])
+    
+    # open a tab in Terminal and run "autotest"
+
+    t = Appscript.app("Terminal")
+    t.launch unless t.is_running?
+    se.application_processes["Terminal"].keystroke("t", :using => :command_down)
+    tab = current_window.tabs.last
+    term.do_script("cd ~/dev/web_site && clear && autotest", :in => tab)
+    
+Using Tornado:
+--------------
+
+    # hide all apps
+    
+    tell OSX do
+        hide_everything
+    end
+    
+    # open a tab in Terminal and run "autotest"
+    tell Terminal do
+        open_new_tab("~/dev/web_site") do
+          run "autotest"
+        end
+    end
+    
+
+Copyright and License
+---------------------
+
+The MIT License
+
+Copyright© 2008 Jim Garvin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,30 @@
+%w[rubygems rake rake/clean fileutils].each { |f| require f }
+$: << "lib"
+require File.dirname(__FILE__) + '/lib/tornado'
+require 'echoe'
+require 'rake/testtask'
+require 'rcov/rcovtask'
+ 
+Echoe.new('tornado', Tornado::VERSION) do |p|
+  p.description = "Ruby DSL for easily launching, arranging and doing other simple tasks with Mac OS X applications."
+  p.url = "http://github.com/coderifous/tornado"
+  p.author = "Jim Garvin"
+  p.email = "jim at thegarvin dot com"
+  p.ignore_pattern = ["rdoc/*", "rcov/*"]
+  p.development_dependencies = []
+  p.runtime_dependencies = ['rb-appscript >=0.5.1']
+end
+
+Rcov::RcovTask.new do |t|
+  t.libs << "test" << "test/helpers"
+  t.pattern    = 'test/test_*.rb'
+  t.output_dir = 'rcov'
+  t.verbose    = true
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test" << "test/helpers"
+  t.test_files = FileList['test/test_*.rb']
+  t.verbose = true
+end
+

data/examples/tornado-cubenot_site.rb

@@ -0,0 +1,35 @@
+#!/usr/local/bin/ruby
+
+require 'rubygems'
+require 'tornado'
+
+DEV_DIR = "~/dev/cubenot_site"
+
+tell OSX do
+  hide_everything
+end
+
+tell Terminal do
+  open_new_tab(DEV_DIR)
+
+  open_new_tab(DEV_DIR) do
+    tail "~/dev/cubenot_site/log/*.log"
+  end
+  
+  open_new_tab(DEV_DIR) do
+    run "autotest"
+  end
+end
+
+tell Textmate do
+  minimize_all_windows
+  open DEV_DIR
+  resize 400, "100%", :animate => true
+  reposition :south_east, :animate => true
+end
+
+tell Firefox do
+  open_new_tab("http://cubenot-site.local")
+end
+
+Textmate.activate

data/lib/applications/finder.rb

@@ -0,0 +1,8 @@
+module Tornado::Applications::Finder
+  
+  def minimize_all_windows
+    app.activate
+    app.windows.collapsed.set(true) # finder uses "collapsed"
+  end
+  
+end

data/lib/applications/firefox.rb

@@ -0,0 +1,9 @@
+module Tornado::Applications::Firefox
+
+  # depends on Firefox being the default browser, and 
+  # configured to open new pages in new tabs
+  def open_new_tab(*args)
+    OSX.open_location(*args)
+  end
+    
+end

data/lib/applications/safari.rb

@@ -0,0 +1,6 @@
+module Tornado::Applications::Safari
+
+  def open_new_tab(*args)
+  end
+  
+end

data/lib/applications/terminal.rb

@@ -0,0 +1,67 @@
+module Tornado::Applications::Terminal
+
+  def open_new_tab(path=nil, &block)
+    Terminal.ensure_launched
+    Terminal.keystroke("t", :using => :command_down)
+    tab = Tab.new(app.windows.first.tabs.last)
+    if path
+      tab.cd(path) 
+      tab.clear
+    end
+    if block_given?
+      tab.instance_eval(&block)
+    end
+    tab
+  end
+  
+  # For some reason (a bug), we have to add the window's height to both y-values in the coordinates
+  def position_top_left_corner_at(x,y, animate=false)
+    b = current_bounds
+    app.windows[0].bounds.set([x, y + height, x + width, y + height + height])
+  end
+
+  # same bug is addressed here
+  def resize(w, h, animate=false)
+    b = current_bounds
+    w = absolutize_size(w, :width)
+    h = absolutize_size(h, :height)
+    app.windows[0].bounds.set([ b[0], b[1] + height, b[0] + w, b[1] + h + height ])
+  end
+  
+  def absolutize_size(size, width_or_height)
+    if size.to_s[-1].chr == "%"
+      OSX.send("desktop_#{width_or_height}") * (size.to_f / 100)
+    else
+      size + height
+    end
+  end
+  
+  class Tab
+    attr_reader :tab
+    
+    def initialize(tab)
+      @tab = tab
+    end
+    
+    def run(cmd)
+      Terminal.do_script(cmd, :in => @tab)
+    end
+    
+    def tail(path)
+      run "tail -f #{path}"
+    end
+    
+    def clear
+      run "clear"
+    end
+    
+    def clear_scrollback
+      @tab.selected.set(true)
+      Terminal.keystroke("k", :using => :command_down)
+    end
+    
+    def cd(path)
+      run "cd #{path}"
+    end
+  end
+end

data/lib/applications/textmate.rb

@@ -0,0 +1,11 @@
+module Tornado::Applications::Textmate
+  def open(*args)
+    args.each do |file_path|
+      file_path.sub!(/~/, ENV["HOME"])
+      app.open(file_path)
+    end
+  end
+end
+
+# in case I jack up textmate's drawer again:
+# defaults write com.macromates.textmate OakProjectDrawerWidth 100

data/lib/generic_application.rb

@@ -0,0 +1,160 @@
+require 'osx'
+
+module GenericActions
+  def close_all_windows
+    app.windows.close
+  end
+  
+  def minimize_all_windows
+    app.activate
+    app.windows.get.select { |w| w.visible.get }.each do |window|
+      window.miniaturized.set(true)
+    end
+  end
+  
+  def wait_for_me!
+    sleep(0.1) while !is_running?
+  end
+
+  def ensure_launched
+    unless is_running?
+      app.launch
+      wait_for_me!
+    end
+  end
+  
+  def keystroke(*args)
+    OSX[name].keystroke(*args)
+  end
+  
+  # blindly pass on unrecognized methods to the appscript proxy
+  def method_missing(meth, *args)
+    app.send(meth, *args)
+  end
+end
+
+module WindowPositionAndResizeActions
+  def current_bounds
+    app.windows[0].bounds.get
+  end
+  
+  def position(cardinal_point, opts={})
+    x, y = nil, nil
+    case cardinal_point
+      when :north_east
+        x = OSX.desktop_width - width
+        y = 0
+      when :south_east
+        x = OSX.desktop_width - width
+        y = OSX.desktop_height - height
+      when :north_west
+        x, y = 0, 0
+      when :south_west
+        x = 0
+        y = OSX.desktop_height - height
+    end
+    position_top_left_corner_at(x, y, opts)
+  end
+  
+  def position_top_left_corner_at(x, y, opts={})
+    b = current_bounds
+    end_bounds = [x, y, x + width, y + height]
+    if opts[:animate]
+      transition_to_bounds(b, end_bounds)
+    else
+      app.windows[0].bounds.set(end_bounds)
+    end
+  end
+  
+  def width
+    b = current_bounds
+    b[2] - b[0]
+  end
+  
+  def height
+    b = current_bounds
+    b[3] - b[1]
+  end
+  
+  def resize(w, h, opts={})
+    b = current_bounds
+    w = absolutize_size(w, :width)
+    h = absolutize_size(h, :height)
+    end_bounds = [ b[0], b[1], b[0] + w, b[1] + h ]
+    if opts[:animate]
+      transition_to_bounds(b, end_bounds)
+    else
+      app.windows[0].bounds.set(end_bounds)
+    end
+  end
+  
+  def transition_to_bounds(start_bounds, end_bounds)
+    # puts "From #{start_bounds.inspect} to #{end_bounds.inspect}"
+    steps = 50
+    factor = 100 / steps
+    1.upto(steps) do |step|
+      frac = step.to_f * factor / 100
+      step_bounds = []
+      0.upto(3) do |x|
+        step_bounds[x] = start_bounds[x] + ((end_bounds[x] - start_bounds[x]) * frac)
+      end
+      # puts "bounds: #{step_bounds.inspect}"
+      app.windows[0].bounds.set(step_bounds)
+    end
+  end
+  
+  def absolutize_size(size, width_or_height)
+    if size.to_s[-1].chr == "%"
+      OSX.send("desktop_#{width_or_height}") * (size.to_f / 100)
+    else
+      size
+    end
+  end
+end
+
+module ExtensionHelpers
+  def extension
+    Tornado::Applications.const_get(name)
+  end
+  
+  def extension_path
+    "applications/#{name.downcase.tr(" ", '_')}.rb"
+  end
+  
+  def load_extension!
+    begin
+      require extension_path
+      self.extend(extension)
+    rescue NameError => e
+      STDERR.puts "Extension not loaded: Expected #{extension_path} to define module Tornado::Applications::#{name}"
+      STDERR.puts caller
+    rescue LoadError => e
+      STDERR.puts "Extension not found: #{extension_path}"
+    end
+  end
+end
+
+class GenericApplication
+  include GenericActions
+  include ExtensionHelpers
+  include WindowPositionAndResizeActions
+  
+  attr_accessor :app, :name
+  
+  def initialize(opts)
+    opts.each_pair { |k,v| self.send("#{k}=", v) }
+    self.app = Appscript.app(name)
+  end
+  
+  def self.find_by_string(name)
+    if Appscript.app(name)
+      application = GenericApplication.new(:name => name)
+      application.load_extension!
+      Kernel.const_set(name, application)
+      return application
+    else
+      STDERR.puts "Couldn't find application named: #{name}"
+      return false
+    end
+  end
+end

data/lib/osx.rb

@@ -0,0 +1,35 @@
+class OSX
+  class << self
+    def hide_everything
+      system_events.keystroke("h", :using => [ :command_down, :option_down ])
+    end
+    
+    def open_location(*args)
+      args.each { |url| system_events.open_location(url) }
+    end
+    
+    def system_events
+      @system_events ||= Appscript.app("System Events")
+    end
+    
+    def [](app_name)
+      system_events.application_processes[app_name]
+    end
+    
+    def running_applications
+      system_events.application_processes.get.collect { |a| a.name.get }
+    end
+    
+    def desktop_size
+      @desktop_size ||= Finder.desktop.window.bounds.get
+    end
+    
+    def desktop_width
+      desktop_size[2]
+    end
+    
+    def desktop_height
+      desktop_size[3]
+    end
+  end
+end

data/lib/tornado.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'appscript'
+
+module Tornado
+  VERSION = "0.0.1"
+  
+  def tell(app, &block)
+    if block_given?
+      app.instance_eval &block
+    end 
+  end
+  
+  def const_missing(name)
+    return GenericApplication.find_by_string(name.to_s) || super(name)
+  end
+  
+  module Applications; end
+end
+
+Object.extend(Tornado)
+extend(Tornado)
+
+require 'generic_application'
+

data/test/helpers/test_helpers.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+require 'tornado'
+
+module TestHelpers
+  def assert_responds_to(object, *methods)
+    methods.each do |m| 
+      assert object.respond_to?(m), "failed to respond to '#{m}'"
+    end
+  end
+  
+  def assert_application_not_defined(app_name)
+    assert ! application_defined?(app_name)
+  end
+  
+  def assert_application_defined(app_name)
+    assert application_defined?(app_name)
+  end
+  
+  def assert_extension_not_defined(app_name)
+    assert ! Tornado::Applications.const_defined?(app_name)
+  end
+  
+  def application_defined?(app_name)
+    Kernel.const_defined?(app_name)
+  end
+  
+  def ensure_application_undefined(app_name)
+    Kernel.send(:remove_const, app_name) if application_defined?(app_name)
+  end
+  
+  def first_mention_of(*args)
+    # called solely for side effect of arguments being mentioned
+  end
+end

data/test/test_application_finder.rb

@@ -0,0 +1,21 @@
+require 'helpers/test_helpers'
+
+class ApplicationFinderTest < Test::Unit::TestCase
+  
+  context "The Finder application" do
+    
+    setup do
+      Appscript.stubs(:app).returns(mock)
+    end
+    
+    should "be able to minimize all windows" do
+      Finder.app.expects(:activate)
+      mock2 = mock { expects(:set).with(true) }
+      mock1 = mock { expects(:collapsed).returns(mock2) }
+      Finder.app.expects(:windows).returns(mock1)
+      Finder.minimize_all_windows
+    end
+    
+  end
+  
+end

data/test/test_application_osx.rb

@@ -0,0 +1,60 @@
+require 'helpers/test_helpers'
+
+class ApplicationOSXTest < Test::Unit::TestCase
+  
+  context "The tornado pseudo-app OSX" do
+    
+    should "return the desktop size" do
+      bounds  = mock { expects(:get).returns([0,0,1440,900]) }
+      window  = mock { expects(:bounds).returns(bounds) }
+      desktop = mock { expects(:window).returns(window) }
+      Finder.expects(:desktop).returns(desktop)
+      assert_equal [0,0,1440,900], OSX.desktop_size
+    end
+    
+    should "use the System Events app" do
+      Appscript.expects(:app).with("System Events")
+      OSX.instance_variable_set(:@system_events, nil)
+      OSX.system_events
+    end
+    
+    should "use system events to hide all windows" do
+      OSX.system_events.expects(:keystroke).with("h", :using => [ :command_down, :option_down ])
+      OSX.hide_everything
+    end
+    
+    should "use system events to open urls" do
+      OSX.system_events.expects(:open_location).with("foo")
+      OSX.open_location("foo")
+    end
+    
+    should "use system events to access application processes by name" do
+      processes = mock("processes"){ expects(:[] => "Foo") }
+      OSX.system_events.expects(:application_processes).returns(processes)
+      OSX["Foo"]
+    end
+    
+    context "with running applications %w(Foo Bar Baz)" do
+      
+      setup do
+        list = [ 
+          stub(:name => stub(:get => "Foo")), 
+          stub(:name => stub(:get => "Bar")),
+          stub(:name => stub(:get => "Baz")) 
+        ]
+        processes = mock() do
+          expects(:get).returns(list).at_least_once
+        end
+        OSX.system_events.expects(:application_processes).returns(processes).at_least_once
+      end
+      
+      should "use system events to list application processes by name" do
+        list = OSX.running_applications
+        assert_equal %w(Foo Bar Baz), list
+      end
+      
+    end
+    
+  end
+  
+end

data/test/test_application_terminal.rb

@@ -0,0 +1,67 @@
+require 'helpers/test_helpers'
+
+class ApplicationTerminalTest < Test::Unit::TestCase
+  
+  context "The Terminal application" do
+    
+    context "with a tab" do
+      
+      setup do
+        Terminal
+        @tab = Tornado::Applications::Terminal::Tab.new(stub)
+      end
+      
+      should "be able to call run on tab" do
+        Terminal.expects(:do_script).with("foo", :in => @tab.tab)
+        @tab.run "foo"
+      end
+      
+      should "be able to call clear on tab" do
+        @tab.expects(:run).with("clear")
+        @tab.clear
+      end
+      
+      should "be able to call clear scroll back" do
+        @tab.tab.expects(:selected).returns(mock { expects(:set).with(true) })
+        Terminal.expects(:keystroke).with("k", :using => :command_down)
+        @tab.clear_scrollback
+      end
+      
+      should "be able to change directory" do
+        @tab.expects(:run).with("cd /path")
+        @tab.cd("/path")
+      end
+      
+    end
+    
+    context "with mocked out tab" do
+      
+      setup do
+        Terminal.expects(:ensure_launched)
+        Terminal.expects(:keystroke).with("t", :using => :command_down)
+        @tab = mock
+        Tornado::Applications::Terminal::Tab.expects(:new).returns(@tab)
+      end
+    
+      should "be able to open_new_tab without a path" do
+        Terminal.open_new_tab
+      end
+      
+      should "be able to open_new_tab with a path" do
+        @tab.expects(:cd).with("/path/foo")
+        @tab.expects(:clear)
+        Terminal.open_new_tab("/path/foo")
+      end
+      
+      should "be able to open_new_tab with a block" do
+        @tab.expects(:some_method)
+        Terminal.open_new_tab do
+          some_method
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/test/test_generic_application.rb

@@ -0,0 +1,125 @@
+require 'helpers/test_helpers'
+
+class GenericApplicationTest < Test::Unit::TestCase
+  include TestHelpers
+  
+  context "A GenericApplication" do
+    
+    setup do
+      Appscript.stubs(:app).returns(mock("app"))
+      OSX.stubs(:desktop_size).returns([0, 0, 1024, 768])
+      @generic_app = GenericApplication.new(:name => "FakeApplication")
+    end
+    
+    should "be able to resize first window with absolute values" do
+      bounds = mock { expects(:set).with([100 , 100, 500, 500]) }
+      windows = [ mock(:bounds => bounds) ]
+      @generic_app.app.expects(:windows).returns(windows)
+      @generic_app.expects(:current_bounds).returns([100,100,200,200])
+      @generic_app.resize 400, 400
+    end
+    
+    should "be able to resize first window with percent values" do
+      bounds = mock { expects(:set).with([100 , 100, 612, 484]) }
+      windows = [ mock(:bounds => bounds) ]
+      @generic_app.app.expects(:windows).returns(windows)
+      @generic_app.expects(:current_bounds).returns([100,100,200,200])
+      @generic_app.resize "50%", "50%"
+    end
+
+    context "with position bzz" do
+      setup do
+        @generic_app.stubs(:current_bounds).returns([100,100,200,200])
+        @bounds = mock
+        windows = [ mock(:bounds => @bounds) ]
+        @generic_app.app.expects(:windows).returns(windows)
+      end
+      
+      should "be able to position first window in :north_east" do
+        @bounds.expects(:set).with([924, 0, 1024, 100])
+        @generic_app.position :north_east
+      end
+      
+      should "be able to position first window in :south_east" do
+        @bounds.expects(:set).with([924, 668, 1024, 768])
+        @generic_app.position :south_east
+      end
+      
+      should "be able to position first window in :north_west" do
+        @bounds.expects(:set).with([0, 0, 100, 100])
+        @generic_app.position :north_west
+      end
+      
+      should "be able to position first window in :south_west" do
+        @bounds.expects(:set).with([0, 668, 100, 768])
+        @generic_app.position :south_west
+      end
+    end
+    
+    should "be able to close all windows" do
+      windows = mock("windows") { expects(:close) }
+      @generic_app.app.expects(:windows).returns(windows)
+      @generic_app.close_all_windows
+    end
+    
+    should "be able to minimize all windows" do
+      stub_get_true  = stub(:get => true, :set => nil)
+      stub_get_false = stub(:get => false)
+      @generic_app.app.expects(:activate)
+      window = mock("window") do
+        expects(:visible).returns(stub_get_true).times(3)
+        expects(:miniaturized).returns(stub_get_true).times(3)
+      end
+      non_visible_window = mock("non_visible_window") do
+        expects(:visible).returns(stub_get_false)
+        expects(:miniaturized).never
+      end
+      windows = mock(:get => [window, window, window, non_visible_window])
+      @generic_app.app.expects(:windows).returns(windows)
+      @generic_app.minimize_all_windows
+    end
+    
+    should "be able to wait_for_me" do
+      @generic_app.expects(:sleep).times(2)
+      @generic_app.expects(:is_running?).times(3).returns(false, false, true)
+      @generic_app.wait_for_me!
+    end
+    
+    should "be able to ensure_launched" do
+      @generic_app.expects(:is_running?).returns(false)
+      @generic_app.app.expects(:launch)
+      @generic_app.expects(:wait_for_me!)
+      @generic_app.ensure_launched
+    end
+    
+    should "be able to send keystrokes" do
+      key, options = "h", { :using => :command_down }
+      receiver     = mock { expects(:keystroke).with(key, options) }
+      OSX.expects(:[]).with("FakeApplication").returns(receiver)
+      @generic_app.keystroke(key, options)
+    end
+      
+    should "send unrecognized methods to app" do
+      @generic_app.app.expects(:a_method_that_does_not_exist)
+      @generic_app.a_method_that_does_not_exist
+    end
+    
+  end
+  
+  def test_extension_loading_for_app_with_extension
+    ensure_application_undefined :Finder
+    assert_application_not_defined :Finder
+    first_mention_of Finder
+    assert_application_defined :Finder
+    assert_equal "applications/finder.rb", Finder.extension_path
+    assert_equal Tornado::Applications::Finder, Finder.extension
+  end
+  
+  def test_extension_loading_for_app_without_extension
+    Appscript.stubs(:app).returns(true)
+    assert_application_not_defined :ApplicationWithoutExtension
+    first_mention_of ApplicationWithoutExtension
+    assert_extension_not_defined :ApplicationWithoutExtension
+  end
+  
+end

data/test/test_tornado.rb

@@ -0,0 +1,27 @@
+require 'helpers/test_helpers'
+
+$main = self
+
+class TornadoTest < Test::Unit::TestCase
+  include TestHelpers
+  include Tornado
+  
+  def test_tell
+    $main.respond_to?(:tell)
+    Object.new.respond_to?(:tell)
+  end
+  
+  def test_automatic_application_reference_based_on_const_missing
+    ensure_application_undefined :Terminal
+    assert_application_not_defined :Terminal
+    first_mention_of Terminal
+    assert Terminal.kind_of?(GenericApplication)
+  end
+  
+  def test_tell
+    fake_app = mock(:nothing => true)
+    tell fake_app do
+      nothing
+    end
+  end
+end

data/tornado.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name = %q{tornado}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jim Garvin"]
+  s.date = %q{2009-01-10}
+  s.description = %q{Ruby DSL for easily launching, arranging and doing other simple tasks with Mac OS X applications.}
+  s.email = %q{jim at thegarvin dot com}
+  s.extra_rdoc_files = ["lib/applications/finder.rb", "lib/applications/firefox.rb", "lib/applications/safari.rb", "lib/applications/terminal.rb", "lib/applications/textmate.rb", "lib/generic_application.rb", "lib/osx.rb", "lib/tornado.rb", "README.markdown"]
+  s.files = ["examples/tornado-cubenot_site.rb", "lib/applications/finder.rb", "lib/applications/firefox.rb", "lib/applications/safari.rb", "lib/applications/terminal.rb", "lib/applications/textmate.rb", "lib/generic_application.rb", "lib/osx.rb", "lib/tornado.rb", "Manifest", "Rakefile", "README.markdown", "test/helpers/test_helpers.rb", "test/test_application_finder.rb", "test/test_application_osx.rb", "test/test_application_terminal.rb", "test/test_generic_application.rb", "test/test_tornado.rb", "tornado.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/coderifous/tornado}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Tornado", "--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{tornado}
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Ruby DSL for easily launching, arranging and doing other simple tasks with Mac OS X applications.}
+  s.test_files = ["test/helpers/test_helpers.rb", "test/test_application_finder.rb", "test/test_application_osx.rb", "test/test_application_terminal.rb", "test/test_generic_application.rb", "test/test_tornado.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_runtime_dependency(%q<rb-appscript>, [">= 0.5.1"])
+    else
+      s.add_dependency(%q<rb-appscript>, [">= 0.5.1"])
+    end
+  else
+    s.add_dependency(%q<rb-appscript>, [">= 0.5.1"])
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: coderifous-tornado
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jim Garvin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-10 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rb-appscript
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.1
+    version: 
+description: Ruby DSL for easily launching, arranging and doing other simple tasks with Mac OS X applications.
+email: jim at thegarvin dot com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/applications/finder.rb
+- lib/applications/firefox.rb
+- lib/applications/safari.rb
+- lib/applications/terminal.rb
+- lib/applications/textmate.rb
+- lib/generic_application.rb
+- lib/osx.rb
+- lib/tornado.rb
+- README.markdown
+files: 
+- examples/tornado-cubenot_site.rb
+- lib/applications/finder.rb
+- lib/applications/firefox.rb
+- lib/applications/safari.rb
+- lib/applications/terminal.rb
+- lib/applications/textmate.rb
+- lib/generic_application.rb
+- lib/osx.rb
+- lib/tornado.rb
+- Manifest
+- Rakefile
+- README.markdown
+- test/helpers/test_helpers.rb
+- test/test_application_finder.rb
+- test/test_application_osx.rb
+- test/test_application_terminal.rb
+- test/test_generic_application.rb
+- test/test_tornado.rb
+- tornado.gemspec
+has_rdoc: true
+homepage: http://github.com/coderifous/tornado
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Tornado
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: tornado
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby DSL for easily launching, arranging and doing other simple tasks with Mac OS X applications.
+test_files: 
+- test/helpers/test_helpers.rb
+- test/test_application_finder.rb
+- test/test_application_osx.rb
+- test/test_application_terminal.rb
+- test/test_generic_application.rb
+- test/test_tornado.rb