launchy 2.0.1 → 2.0.2

data/.gitignore

@@ -0,0 +1,6 @@
+*~
+*.swo
+*.swp
+doc/
+coverage/
+pkg/

data/HISTORY

@@ -1,5 +1,11 @@
 = Launchy Changlog
 
+== Version 2.0.2 - 2011-07-17
+
+* Typo fixes from @mtorrent
+* Documentation updates explicitly stating the Public API
+* Increase test coverage
+
 == Version 2.0.1 - 2011-07-16
 
 * Almost a complete rewrite

data/README

@@ -20,17 +20,32 @@ Currently only launching a browser is supported.
 
 == SYNOPSIS
 
-From within your ruby code you can trust launchy to do the right thing:
+You can use launchy on the commandline, or via its API.
 
-    Launchy.open("http://www.ruby-lang.org/")
+=== Commandline
 
-Or, if you want to launch the application yourself:
+    % launchy http://www.ruby-lang.org/
 
-    Launchy::Browser.open("http://www.ruby-lang.org/")
+There are additional commandline options, use 'launchy --help' to see them.
 
-OR
+=== Public API
 
-    Launchy::Browser.new.open("http://www.ruby-lang.org/")
+In the vein of {Semantic Versioning}[http://semver.org], starting with version 2.0.0, this is the
+sole supported public API.
+
+    Launchy.open( uri, options = {} )
+
+At the moment, the only available options are:
+
+    :debug        Turn on debugging output
+    :application  Explicitly state what application class is going to be used
+    :host_os      Explicitly state what host operating system to pretend to be
+    :ruby_engine  Explicitly state what ruby engine to pretend to be under
+    :dry_run      Do nothing and print the command that would be executed on $stdout
+
+An example of using the public API:
+
+    Launchy.open( "http://www.ruby-lang.org" )
 
 == ISC LICENSE
 

data/Rakefile

@@ -45,10 +45,15 @@ _
     gem.extras = { :platform => Gem::Platform.new( "java" ) }
   end
 
-  depend_on "rake"    , "~> 0.9.2", :development => true
-  depend_on "minitest", "~> 2.3.1", :development => true
-  depend_on 'bones'   , "~> 3.7.0", :development => true
+  depend_on "rake"      , "~> 0.9.2", :development => true
+  depend_on "minitest"  , "~> 2.3.1", :development => true
+  depend_on 'bones'     , "~> 3.7.0", :development => true
+  depend_on 'bones-rcov', "~> 1.0.1", :development => true
+  depend_on 'rcov'      , "~> 0.9.9", :development => true
+  depend_on "spoon"     , "~> 0.0.1", :development => true
 
   test.files = FileList["spec/**/*_spec.rb"]
   test.opts << "-w -Ilib:spec"
+
+  rcov.opts << "--exclude gems"
 }

data/lib/launchy.rb

@@ -1,8 +1,7 @@
 require 'uri'
 
 #
-# Top level entry point into Launchy. Almost everyone will just use the single
-# call:
+# The entry point into Launchy. This is the sole supported public API.
 #
 #   Launchy.open( uri, options = {} )
 #
@@ -12,6 +11,7 @@ require 'uri'
 #   :application  Explicitly state what application class is going to be used
 #   :host_os      Explicitly state what host operating system to pretend to be
 #   :ruby_engine  Explicitly state what ruby engine to pretend to be under
+#   :dry_run      Do nothing and print the command that would be executed on $stdout
 #
 # Other options may be used, and those will be passed directly to the
 # application class
@@ -26,13 +26,8 @@ module Launchy
       begin
         extract_global_options( options )
         uri = URI.parse( uri )
-        if app = Launchy::Application.for_scheme( uri ) then
-          app.new.open( uri, options )
-        else
-          msg = "Unable to launch #{uri} with options #{options.inspect}"
-          Launchy.log "#{self.name} : #{msg}"
-          $stderr.puts msg
-        end
+        app = Launchy::Application.for_scheme( uri )
+        app.new.open( uri, options )
       rescue Exception => e
         msg = "Failure in opening #{uri} with options #{options.inspect}: #{e}"
         Launchy.log "#{self.name} : #{msg}"

data/lib/launchy/application.rb

@@ -63,6 +63,7 @@ module Launchy
     attr_reader :host_os_family
     attr_reader :ruby_engine
     attr_reader :runner
+
     def initialize
       @host_os_family = Launchy::Detect::HostOsFamily.detect
       @ruby_engine    = Launchy::Detect::RubyEngine.detect

data/lib/launchy/applications/browser.rb

@@ -12,7 +12,7 @@ class Launchy::Application
     end
 
     def cygwin_app_list
-      [ "cmd /C start 'launchy' /d" ]
+      [ 'cmd /C start "Launchy" /d' ]
     end
 
     def darwin_app_list
@@ -20,7 +20,7 @@ class Launchy::Application
     end
 
     def nix_app_list
-      nix_de = Launchy::Detect::NixDekstopEnvironment.browser
+      nix_de = Launchy::Detect::NixDesktopEnvironment.detect
       app_list = %w[ xdg-open ]
       app_list << nix_de.browser
       app_list << nix_de.fallback_browsers
@@ -44,25 +44,30 @@ class Launchy::Application
     end
 
     # Get the full commandline of what we are going to add the uri to
-    def browser
+    def browser_cmdline
       possibilities = (browser_env + app_list).flatten
       possibilities.each do |p|
         Launchy.log "#{self.class.name} : possibility : #{p}"
       end
-      b = possibilities.shift
-      Launchy.log "#{self.class.name} : Using browser value '#{b}'"
-      return b
+      browser = possibilities.shift
+      Launchy.log "#{self.class.name} : Using browser value '#{browser}'"
+      return browser
+    end
+
+    def cmd_and_args( uri, options = {} )
+      cmd = browser_cmdline
+      args = [ uri.to_s ]
+      if cmd =~ /%s/ then
+        cmd.gsub!( /%s/, args.shift )
+      end
+      return [cmd, args]
     end
 
     # final assembly of the command and do %s substitution 
     # http://www.catb.org/~esr/BROWSER/index.html
     def open( uri, options = {} )
-      b = browser
-      args = [ uri.to_s ]
-      if b =~ /%s/ then
-        b.gsub!( /%s/, args.shift )
-      end
-      run( b, args )
+      cmd, args = cmd_and_args( uri, options )
+      run( cmd, args )
     end
   end
 end

data/lib/launchy/cli.rb

@@ -17,26 +17,26 @@ module Launchy
 
         op.on( "-a", "--application APPLICATION", 
                "Explicitly specify the application class to use in the launch") do |app|
-          options[:application] = app
+          @options[:application] = app
         end
 
         op.on( "-d", "--debug", 
                "Force debug. Output lots of information.") do |d|
-          options[:debug] = 'true'
+          @options[:debug] = 'true'
         end
 
         op.on( "-e", "--engine RUBY_ENGINE",
                "Force launchy to behave as if it was on a particular ruby engine.") do |e|
-          options[:ruby_engine] = e
+          @options[:ruby_engine] = e
         end
 
         op.on( "-n", "--dry-run", "Don't launchy, print the command to be executed on stdout" ) do |x|
-          options[:dry_run] = true
+          @options[:dry_run] = true
         end
 
         op.on( "-o", "--host-os HOST_OS", 
                "Force launchy to behave as if it was on a particular host os.") do |os|
-          options[:host_os] = os
+          @options[:host_os] = os
         end
 
 
@@ -44,27 +44,40 @@ module Launchy
         op.separator "Standard Options:"
 
         op.on( "-h", "--help", "Print this message.") do |h|
-          puts op.to_s
+          $stdout.puts op.to_s
           exit 0
         end
 
         op.on( "-v", "--version", "Output the version of Launchy") do |v|
-          puts "Launchy version #{Launchy::VERSION}"
+          $stdout.puts "Launchy version #{Launchy::VERSION}"
           exit 0
         end
 
       end
     end
 
-    def run( argv = ARGV, env = ENV )
+    def parse( argv, env )
       begin
         parser.parse!( argv )
-        Launchy.open( argv.shift, options )
+        return true
       rescue ::OptionParser::ParseError => pe
         $stderr.puts "#{parser.program_name}: #{pe}"
         $stderr.puts "Try `#{parser.program_name} --help for more information."
-        exit 1
+        return false
       end
     end
+
+    def good_run( argv, env )
+      if parse( argv, env ) then
+        Launchy.open( argv.shift, options )
+        return true
+      else
+        return false
+      end
+    end
+
+    def run( argv = ARGV, env = ENV )
+      exit 1 unless good_run( argv, env )
+    end
   end
 end

data/lib/launchy/detect/runner.rb

@@ -8,7 +8,17 @@ module Launchy::Detect
 
     # Detect the current command runner
     #
+    # This will return an instance of the Runner to be used to do the
+    # application launching.
+    #
     # If a runner cannot be detected then raise Runner::NotFoundError
+    #
+    # The runner rules are, in order:
+    #
+    # 1) If you are on windows, you use the Windows Runner no matter what
+    # 2) If you are using the jruby engine, use the Jruby Runner. Unless rule
+    #    (1) took effect
+    # 3) Use Forkable (barring rules (1) and (2))
     def self.detect
       host_os_family = Launchy::Detect::HostOsFamily.detect
       ruby_engine    = Launchy::Detect::RubyEngine.detect
@@ -28,8 +38,8 @@ module Launchy::Detect
     #
     def shell_commands( cmd, args )
       cmdline = [ cmd.shellsplit ]
-      cmdline << args.collect{ |a| a.to_s.shellescape }
-      return commanddline_normalize( cmdline )
+      cmdline << args.flatten.collect{ |a| a.to_s.shellescape }
+      return commandline_normalize( cmdline )
     end
 
     def commandline_normalize( cmdline )
@@ -39,9 +49,13 @@ module Launchy::Detect
       return c
     end
 
+    def dry_run( cmd, *args )
+      shell_commands(cmd, args).join(" ")
+    end
+
     def run( cmd, *args )
       if Launchy.dry_run? then
-        puts dry_run( cmd, *args )
+        $stdout.puts dry_run( cmd, *args )
       else
         wet_run( cmd, *args )
       end
@@ -53,40 +67,36 @@ module Launchy::Detect
     #---------------------------------------
 
     class Windows < Runner
+
+      def all_args( cmd, *args )
+        [ 'cmd', '/c', *shell_commands( cmd, *args ) ]
+      end
+
       def dry_run( cmd, *args )
-        "cmd /c #{shell_commands( cmd, args).join(" " )}"
+        all_args( cmd, *args ).join(" ")
       end
 
-      def shell_commands( cmd, args )
+      def shell_commands( cmd, *args )
         cmdline = [ cmd ]
-        cmdline << args.collect { |a| a.to_s.gsub("&", "^&") }
+        cmdline << args.flatten.collect { |a| a.to_s.gsub("&", "^&") }
         return commandline_normalize( cmdline )
       end
 
       def wet_run( cmd, *args )
-        system( 'cmd', '/c', *shell_commands( cmd, *args ) )
+        system( *all_args( cmd, *args ) )
       end
     end
 
     class Jruby < Runner
-
-      def dry_run( cmd, *args )
-        shell_commands(cmd, args).join(" ")
-      end
-
       def wet_run( cmd, *args )
-        Spoon.spawnp( *shell_commands( cmd, args ) )
+        Spoon.spawnp( *shell_commands( cmd, *args ) )
       end
     end
 
     class Forkable < Runner
-      def dry_run( cmd, *args )
-        shell_commands(cmd, args).join(" ")
-      end
-
       def wet_run( cmd, *args )
         child_pid = fork do
-          exec( *shell_commands( cmd, args ))
+          exec( *shell_commands( cmd, *args ))
           exit!
         end
         Process.detach( child_pid )

data/lib/launchy/version.rb

@@ -1,5 +1,5 @@
 module Launchy
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 
   module Version
 

data/spec/applications/browser_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Launchy::Application::Browser do
+  before do
+    Launchy.reset_global_options
+    ENV['KDE_FULL_SESSION'] = "launchy"
+    @test_url = "http://example.com/"
+  end
+
+  after do
+    Launchy.reset_global_options
+    ENV.delete( 'KDE_FULL_SESSION' )
+  end
+
+  { 'windows' => 'start "Launchy" /d' ,
+    'darwin'  => '/usr/bin/open',
+    'cygwin'  => 'cmd /C start "Launchy" /d',
+
+    # when running these tests on a linux box, this test will fail
+    'linux'   => nil                 }.each  do |host_os, cmdline|
+    it "when host_os is '#{host_os}' the appropriate 'app_list' method is called" do
+      Launchy.host_os = host_os
+      browser = Launchy::Application::Browser.new
+      browser.app_list.first.must_equal cmdline
+    end
+  end
+
+  %w[ linux windows darwin cygwin ].each do |host_os|
+    it "the BROWSER environment variable overrides any host defaults on '#{host_os}'" do
+      ENV['BROWSER'] = "my_special_browser --new-tab '%s'"
+      Launchy.host_os = host_os
+      browser = Launchy::Application::Browser.new
+      cmd, args = browser.cmd_and_args( @test_url )
+      cmd.must_equal "my_special_browser --new-tab 'http://example.com/'"
+      args.must_equal []
+    end
+  end
+end
+

data/spec/cli_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Launchy::Cli do
+
+  before do
+    @old_stderr = $stderr
+    $stderr = StringIO.new
+
+    @old_stdout = $stdout
+    $stdout = StringIO.new
+    Launchy.reset_global_options
+  end
+
+  after do
+    Launchy.reset_global_options
+    $stderr = @old_stderr
+    $stdout = @old_stdout
+  end
+
+  def cli_test( argv, env, exit_val, stderr_regex, stdout_regex )
+    begin
+      Launchy::Cli.new.run( argv, env )
+    rescue SystemExit => se
+      se.status.must_equal exit_val
+      $stderr.string.must_match stderr_regex if stderr_regex
+      $stdout.string.must_match stdout_regex if stdout_regex
+    end
+  end
+
+  it "exits 1 when invalid options are given" do
+    cli_test( %w[ -z foo ], {}, 1, /invalid option/, nil )
+  end
+
+  %w[ -h --help ].each do |opt|
+    it "output help and exits 0 when using #{opt}" do
+      cli_test( [ opt ], {}, 0, nil, /Print this message/m )
+    end
+  end
+
+  %w[ -v --version ].each do |opt|
+    it "outputs version and exits 0 when using #{opt}" do
+      cli_test( [ opt ], {}, 0, nil, /Launchy version/ )
+    end
+  end
+
+  it "leaves the url on argv after parsing" do
+    l = Launchy::Cli.new
+    argv = %w[ --debug --dry-run http://github.com/copiousfreetime/launchy ]
+    l.parse( argv , {} )
+    argv.size.must_equal 1
+    argv[0].must_equal "http://github.com/copiousfreetime/launchy" 
+  end
+
+  it "prints the command on stdout when using --dry-run" do
+   argv = %w[ --debug --dry-run http://github.com/copiousfreetime/launchy ]
+   rc = Launchy::Cli.new.good_run( argv, {} )
+   $stdout.string.must_match %r[github.com]
+  end
+
+  {
+    '--application' => [ :application, 'Browser'],
+    '--engine'      => [ :ruby_engine, 'rbx'],
+    '--host-os'     => [ :host_os,     'cygwin'] }.each_pair do |opt, val|
+    it "the commandline option #{opt} sets the program option #{val[0]}" do
+      argv = [ opt, val[1], "http://github.com/copiousfreetime/launchy" ]
+      l = Launchy::Cli.new
+      rc = l.parse( argv, {} )
+      rc.must_equal true
+      argv.size.must_equal 1
+      argv[0].must_equal "http://github.com/copiousfreetime/launchy"
+      l.options[val[0]].must_equal val[1]
+    end
+  end
+end
+ 

data/spec/detect/nix_desktop_environment_spec.rb

@@ -2,12 +2,31 @@ require 'spec_helper'
 
 describe Launchy::Detect::NixDesktopEnvironment do
 
- { "KDE_FULL_SESSION"         => Launchy::Detect::NixDesktopEnvironment::Kde,
-   "GNOME_DESKTOP_SESSION_ID" => Launchy::Detect::NixDesktopEnvironment::Gnome }.each_pair do |k,v|
+  before do
+    Launchy.reset_global_options
+  end
+
+  after do
+    Launchy.reset_global_options
+  end
+
+
+  { "KDE_FULL_SESSION"         => Launchy::Detect::NixDesktopEnvironment::Kde,
+    "GNOME_DESKTOP_SESSION_ID" => Launchy::Detect::NixDesktopEnvironment::Gnome }.each_pair do |k,v|
     it "can detect the desktop environment of a *nix machine using ENV[#{k}]" do
       ENV[k] = "launchy-test"
-      Launchy::Detect::NixDesktopEnvironment.detect.must_equal v
+      nix_env = Launchy::Detect::NixDesktopEnvironment.detect
+      nix_env.must_equal( v )
+      nix_env.browser.must_equal( v.browser )
       ENV.delete( k )
     end
+   end
+
+
+  it "raises an error if it cannot determine the *nix desktop environment" do
+    Launchy.host_os = "linux"
+    ENV.delete( "KDE_FULL_SESSION" )
+    ENV.delete( "GNOME_DESKTOP_SESSION_ID" )
+    lambda { Launchy::Detect::NixDesktopEnvironment.detect }.must_raise Launchy::Detect::NixDesktopEnvironment::NotFoundError
   end
 end

data/spec/detect/runner_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Launchy::Detect::Runner do
+  before do
+    Launchy.reset_global_options
+    @test_url = "http://example.com/?foo=bar&baz=wibble"
+  end
+
+  after do
+    Launchy.reset_global_options
+  end
+
+  it "raises an error when there is an unknown host os" do
+    Launchy.host_os = "foo"
+    lambda{ Launchy::Detect::Runner.detect }.must_raise Launchy::Detect::HostOsFamily::NotFoundError
+  end
+
+  it "raises an error when there is an unknown ruby engine" do
+    Launchy.ruby_engine = "wibble"
+    lambda{ Launchy::Detect::Runner.detect }.must_raise Launchy::Detect::RubyEngine::NotFoundError
+  end
+
+  # On anything that has fork, use Forkable
+  %w[ linux darwin cygwin ].each do |host_os|
+    %w[ ruby rbx macruby ].each do |engine_name|
+      it "engine '#{engine_name}' on OS '#{host_os}' uses runner Forkable" do
+        Launchy.host_os = host_os
+        Launchy.ruby_engine = engine_name
+        engine = Launchy::Detect::Runner.detect
+        engine.must_be_instance_of Launchy::Detect::Runner::Forkable
+      end
+    end
+  end
+
+
+  # Jruby always uses the Jruby runner except on Windows
+  { 'mingw'  => Launchy::Detect::Runner::Windows,
+    'linux'  => Launchy::Detect::Runner::Jruby,
+    'darwin' => Launchy::Detect::Runner::Jruby,
+    'cygwin' => Launchy::Detect::Runner::Jruby, }.each_pair do |host_os, runner|
+    it "engine 'jruby' on OS '#{host_os}' uses runner #{runner.name}" do
+      Launchy.host_os = host_os
+      Launchy.ruby_engine = 'jruby'
+      engine = Launchy::Detect::Runner.detect
+      engine.must_be_instance_of runner
+    end
+  end
+
+  # If you are on windows, no matter what engine, you use the windows runner
+  %w[ ruby rbx jruby macruby ].each do |engine_name|
+    it "uses a Windows runner when the engine is '#{engine_name}'" do
+      Launchy.host_os = "mingw"
+      Launchy.ruby_engine = engine_name
+      e = Launchy::Detect::Runner.detect
+      e.must_be_instance_of Launchy::Detect::Runner::Windows
+    end
+  end
+
+  it "Windows launches use the 'cmd' command" do
+    win = Launchy::Detect::Runner::Windows.new
+    cmd = win.dry_run( "not-really", [ "http://example.com" ] )
+    cmd.must_equal 'cmd /c not-really http://example.com'
+  end
+
+  it "Windows escapes '&' in urls" do
+    win = Launchy::Detect::Runner::Windows.new
+    win.all_args( "not-really", [ @test_url ] ).must_equal [ 'cmd', '/c', 'not-really', 'http://example.com/?foo=bar^&baz=wibble' ]
+
+    cmd = win.dry_run( "not-really", [ @test_url ] )
+    cmd.must_equal 'cmd /c not-really http://example.com/?foo=bar^&baz=wibble'
+  end
+
+  it "Jruby escapes '&' in urls" do
+    jruby = Launchy::Detect::Runner::Jruby.new
+    cmd = jruby.dry_run( "not-really", [ @test_url ])
+    cmd.must_equal 'not-really http://example.com/\\?foo\\=bar\\&baz\\=wibble'
+  end
+
+end

data/spec/launchy_spec.rb

@@ -4,10 +4,13 @@ describe Launchy do
 
   before do
     Launchy.reset_global_options
+    @stderr  = $stderr
+    $stderr = StringIO.new
   end
 
   after do
     Launchy.reset_global_options
+    $stderr = @stderr
   end
 
   it "logs to stderr when LAUNCHY_DEBUG environment variable is set" do
@@ -39,4 +42,10 @@ describe Launchy do
     Launchy.extract_global_options(  { :ruby_engine => "myruby" } )
     Launchy.ruby_engine.must_equal 'myruby'
   end
+
+  it "prints an error on stderr when no scheme is found for the given uri" do
+    Launchy.open( "blah://something/invalid" )
+    $stderr.string.must_match( /Failure in opening/ )
+  end
+
 end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require 'rubygems'
+gem 'minitest'
 require 'minitest/autorun'
 require 'minitest/pride'
 require 'launchy'

data/spec/version_spec.rb

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe 'Launchy::VERSION' do
   it "should have a #.#.# format" do
-    Launchy::VERSION.must_match /\d+\.\d+\.\d+/
+    Launchy::VERSION.must_match( /\d+\.\d+\.\d+/ )
+    Launchy::Version.to_s.must_match( /\d+\.\d+\.\d+/ )
     Launchy::Version.to_a.each do |n|
       n.to_i.must_be :>=, 0
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: launchy
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: 
   segments: 
   - 2
   - 0
-  - 1
-  version: 2.0.1
+  - 2
+  version: 2.0.2
 platform: ruby
 authors: 
 - Jeremy Hinegardner
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-16 00:00:00 -06:00
+date: 2011-07-17 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -67,9 +67,57 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: bones
+  name: bones-rcov
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: spoon
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -81,7 +129,7 @@ dependencies:
         - 0
         version: 3.7.0
   type: :development
-  version_requirements: *id004
+  version_requirements: *id007
 description: |
   Launchy is helper class for launching cross-platform applications in a
   fire and forget manner.
@@ -102,7 +150,7 @@ extra_rdoc_files:
 - README
 - bin/launchy
 files: 
-- .autotest
+- .gitignore
 - HISTORY
 - LICENSE
 - NOTES
@@ -124,10 +172,13 @@ files:
 - lib/launchy/os_family.rb
 - lib/launchy/version.rb
 - spec/application_spec.rb
+- spec/applications/browser_spec.rb
+- spec/cli_spec.rb
 - spec/detect/host_os_family_spec.rb
 - spec/detect/host_os_spec.rb
 - spec/detect/nix_desktop_environment_spec.rb
 - spec/detect/ruby_engine_spec.rb
+- spec/detect/runner_spec.rb
 - spec/launchy_spec.rb
 - spec/mock_scheme.rb
 - spec/spec_helper.rb
@@ -170,9 +221,12 @@ specification_version: 3
 summary: Launchy is helper class for launching cross-platform applications in a fire and forget manner.
 test_files: 
 - spec/application_spec.rb
+- spec/applications/browser_spec.rb
+- spec/cli_spec.rb
 - spec/detect/host_os_family_spec.rb
 - spec/detect/host_os_spec.rb
 - spec/detect/nix_desktop_environment_spec.rb
 - spec/detect/ruby_engine_spec.rb
+- spec/detect/runner_spec.rb
 - spec/launchy_spec.rb
 - spec/version_spec.rb

data/.autotest

@@ -1,28 +0,0 @@
-# vim: ft=ruby
-
-require 'autotest/growl'
-
-Autotest.add_hook :initialize do |at|
-
-  at.libs = "lib:spec"
-  at.testlib = 'minitest/autorun'
-
-  at.add_exception 'coverage.info'
-  at.add_exception 'coverage'
-  at.add_exception '.git'
-
-  at.clear_mappings
-
-  at.add_mapping(%r|^spec/.*_spec\.rb$|) do |filename, _|
-    filename
-  end
-
-  at.add_mapping(%r|^lib/(.*)\.rb$|) do |_, match|
-    [ "test/#{match[1]}_spec.rb" ]
-  end
-
-  at.add_mapping(%r|^spec/spec_helper\.rb|) do
-    at.files_matching( %r|^spec/.*_spec\.rb| )
-  end
-end
-