launchy 2.1.2 → 2.2.0

data/CONTRIBUTING.md

@@ -0,0 +1,52 @@
+# Hi there!
+
+I see you are interested in contributing. That is wonderful. I love
+contributions.
+
+I guarantee that there are bugs in this software. And I guarantee that there is
+a feature you want that is not in here yet. As such, any and all bugs reports
+are gratefully accepted, bugfixes even more so. Helping out with bugs is the
+easiest way to contribute.
+
+
+## The Quick Version
+
+* Have a [GitHub Account][].
+* Search the [GitHub Issues][] and see if your issue already present. If so
+  add your comments, :thumbsup:, etc.
+* Issue not there? Not a problem, open up a [new issue][].
+    * **Bug reports** please be as detailed as possible. Include:
+        * full ruby engine and version: `ruby -e 'puts RUBY_DESCRIPTION'`
+        * operating system and version
+        * version of launchy `ruby -rubygems -Ilib -e "require 'launchy'; puts Launchy::VERSION"`
+        * as much detail about the bug as possible so I can replicate it. Feel free
+          to link in a [gist][]
+    * **New Feature**
+        * What the new feature should do.
+        * What benefit the new feature brings to the project.
+* Fork the [repo][].
+* Create a new branch for your issue: `git checkout -b issue/my-issue`
+* Lovingly craft your contribution:
+    * `rake develop` to get started, or if you prefer bundler `rake develop:using_bundler && bundle`.
+    * `rake test` to run tests
+* Make sure that `rake test` passes. It's important, I said it twice.
+* Add yourself to the contributors section below.
+* Submit your [pull request][].
+
+# Contributors
+
+* [Jeremy Hinegardner][https://github.com/copiousfreetime]
+* [Mike Farmer][https://github.com/mikefarmer]
+* [Suraj N. Kurapati][https://github.com/sunaku]
+* [Postmodern][https://github.com/postmodern]
+* [Stephen Judkins][https://github.com/stephenjudkins]
+* [Mariusz Pietrzyk][https://github.com/wijet]
+* [Bogdan Gusiev][https://github.com/bogdan]
+* [Miquel Rodríguez Telep][https://github.com/mrtorrent]j
+
+[GitHub Account]: https://github.com/signup/free "GitHub Signup"
+[GitHub Issues]:  https://github.com/copiousfreetime/launchy/issues "Launchy Issues"
+[new issue]:      https://github.com/copiousfreetime/launchy/issues/new "New Launchy Issue"
+[gist]:           https://gist.github.com/ "New Gist"
+[repo]:           https://github.com/copiousfreetime/launchy "Launchy Repo"
+[pull request]:   https://help.github.com/articles/using-pull-requests "Using Pull Requests"

data/HISTORY.rdoc

@@ -1,4 +1,13 @@
 = Launchy Changlog
+== Version 2.2.0 - 2013-02-06
+
+* Change XFCE detection to not depend on grep (copiousfreetime/launchy#52 - thanks bogdan)
+* Suppress forked process output (copiousfreetime/launchy#51)
+* Display help/usage if no url is given (copiousfreetime/launchy#54)
+* Detect the fluxbox environment (copiousfreetime/launchy#53)
+* Automatically detect 'http' url's if they are missing the 'http://' (copiousfreetime/launchy#55)
+* Update to latest project management rake tasks
+
 == Version 2.1.2 - 2012-08-06
 
 * Fix where HostOS would fail to convert to string on JRuby in 1.9 mode (copiousfreetime/launchy#45)
@@ -14,7 +23,6 @@
 * Add LAUNCHY_DRY_RUN environment variable (thanks Mariusz Pietrzyk / wijet)
 * Update dependencies
 
-
 == Version 2.0.5 - 2011-07-24
 
 * Fix the case where $BROWSER is set and no *nix desktop was found (copiousfreetime/launchy#33)

data/LICENSE

@@ -1,6 +1,6 @@
 ISC LICENSE - http://opensource.org/licenses/isc-license.txt
 
-Copyright (c) 2007-2011 Jeremy Hinegardner
+Copyright (c) 2007-2013 Jeremy Hinegardner
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

data/Manifest.txt

@@ -1,7 +1,7 @@
+CONTRIBUTING.md
 HISTORY.rdoc
 LICENSE
 Manifest.txt
-NOTES
 README.rdoc
 Rakefile
 bin/launchy
@@ -33,3 +33,5 @@ spec/mock_application.rb
 spec/spec_helper.rb
 spec/tattle-host-os.yaml
 spec/version_spec.rb
+tasks/default.rake
+tasks/this.rb

data/README.rdoc

@@ -83,7 +83,7 @@ in the github gem if it was updated to use 2.0.x but not use the supported API.
 
 http://opensource.org/licenses/isc-license.txt
 
-Copyright (c) 2007-2011 Jeremy Hinegardner
+Copyright (c) 2007-2013 Jeremy Hinegardner
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

data/Rakefile

@@ -1,298 +1,21 @@
 # vim: syntax=ruby
+load 'tasks/this.rb'
 
 This.name     = "launchy"
 This.author   = "Jeremy Hinegardner"
 This.email    = "jeremy@copiousfreetime.org"
 This.homepage = "http://github.com/copiousfreetime/#{ This.name }"
-This.version  = Util.version
 
-#------------------------------------------------------------------------------
-# If you want to Develop on this project just run 'rake develop' and you'll
-# have all you need to get going. If you want to use bundler for development,
-# then run 'rake develop:using_bundler'
-#------------------------------------------------------------------------------
-namespace :develop do
+This.ruby_gemspec do |spec|
+  spec.add_dependency( 'addressable', '~> 2.3')
 
-  # Install all the development and runtime dependencies of this gem using the
-  # gemspec.
-  task :default do
-    require 'rubygems/dependency_installer'
-    installer = Gem::DependencyInstaller.new
-
-    puts "Installing gem depedencies needed for development"
-    Util.platform_gemspec.dependencies.each do |dep|
-      if dep.matching_specs.empty? then
-        puts "Installing : #{dep}"
-        installer.install dep
-      else
-        puts "Skipping   : #{dep} -> already installed #{dep.matching_specs.first.full_name}"
-      end
-    end
-    puts "\n\nNow run 'rake test'"
-  end
-
-  # Create a Gemfile that just references the gemspec
-  file 'Gemfile' => :gemspec do
-    File.open( "Gemfile", "w+" ) do |f|
-      f.puts 'source :rubygems'
-      f.puts 'gemspec'
-    end
-  end
-
-  desc "Create a bundler Gemfile"
-  task :using_bundler => 'Gemfile' do
-    puts "Now you can 'bundle'"
-  end
-
-  # Gemfiles are build artifacts
-  CLOBBER << FileList['Gemfile*']
-end
-desc "Boostrap development"
-task :develop => "develop:default"
-
-#------------------------------------------------------------------------------
-# Minitest - standard TestTask
-#------------------------------------------------------------------------------
-begin
-  require 'rake/testtask'
-  Rake::TestTask.new( :test ) do |t|
-    t.ruby_opts    = %w[ -w -rubygems ]
-    t.libs         = %w[ lib spec ]
-    t.pattern      = "spec/**/*_spec.rb"
-  end
-  task :default => :test
-rescue LoadError
-  Util.task_warning( 'test' )
-end
-
-#------------------------------------------------------------------------------
-# RDoc - standard rdoc rake task, although we must make sure to use a more
-#        recent version of rdoc since it is the one that has 'tomdoc' markup
-#------------------------------------------------------------------------------
-begin
-  gem 'rdoc' # otherwise we get the wrong task from stdlib
-  require 'rdoc/task'
-  RDoc::Task.new do |t|
-    t.markup   = 'tomdoc'
-    t.rdoc_dir = 'doc'
-    t.main     = 'README.rdoc'
-    t.title    = "#{This.name} #{This.version}"
-    t.rdoc_files.include( '*.rdoc', 'lib/**/*.rb' )
-  end
-rescue LoadError => le
-  Util.task_warning( 'rdoc' )
-end
-
-#------------------------------------------------------------------------------
-# Coverage - optional code coverage, rcov for 1.8 and simplecov for 1.9, so
-#            for the moment only rcov is listed.
-#------------------------------------------------------------------------------
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.libs      << 'spec'
-    t.pattern   = 'spec/**/*_spec.rb'
-    t.verbose   = true
-    t.rcov_opts << "-x ^/"           # remove all the global files
-    t.rcov_opts << "--sort coverage" # so we see the worst files at the top
-  end
-rescue LoadError
-  $stderr.puts "rcov task is not defined, please 'gem install rcov'"
-end
-
-#------------------------------------------------------------------------------
-# Manifest - We want an explicit list of thos files that are to be packaged in
-#            the gem. Most of this is from Hoe.
-#------------------------------------------------------------------------------
-namespace 'manifest' do
-  desc "Check the manifest"
-  task :check => :clean do
-    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
-    files = files.select{ |f| File.file?( f ) }
-
-    tmp = "Manifest.tmp"
-    File.open( tmp, 'w' ) do |f|
-      f.puts files.join("\n")
-    end
-
-    begin
-      sh "diff -du Manifest.txt #{tmp}"
-    ensure
-      rm tmp
-    end
-    puts "Manifest looks good"
-  end
-
-  desc "Generate the manifest"
-  task :generate => :clean do
-    files = %x[ git ls-files ].split("\n").sort
-    files.reject! { |f| f =~ This.exclude_from_manifest }
-    File.open( "Manifest.txt", "w" ) do |f|
-      f.puts files.join("\n")
-    end
-  end
-end
-
-#------------------------------------------------------------------------------
-# Gem Specification
-#------------------------------------------------------------------------------
-This.gemspec = Hash.new
-This.gemspec['ruby'] = Gem::Specification.new do |spec|
-  spec.name        = This.name
-  spec.version     = This.version
-  spec.author      = This.author
-  spec.email       = This.email
-  spec.homepage    = This.homepage
-
-  spec.summary     = This.summary
-  spec.description = This.description
-
-  spec.files       = This.manifest
-  spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
-  spec.test_files  = spec.files.grep(/^spec/)
-
-  spec.extra_rdoc_files += spec.files.grep(/(txt|rdoc)$/)
-  spec.rdoc_options = [ "--main"  , 'README.rdoc', ]
-
-  # The Runtime Dependencies
-  spec.add_runtime_dependency( 'addressable', '~> 2.3' )
-
-  # The Development Dependencies
-  spec.add_development_dependency( 'rake'     , '~> 0.9.2.2')
-  spec.add_development_dependency( 'minitest' , '~> 3.3.0' )
+  spec.add_development_dependency( 'rake'     , '~> 10.0.3')
+  spec.add_development_dependency( 'minitest' , '~> 4.5.0' )
   spec.add_development_dependency( 'rdoc'     , '~> 3.12'   )
-  spec.add_development_dependency( 'spoon'    , '~> 0.0.1'  )
-  spec.add_development_dependency( 'ffi'      , '~> 1.1.1'  )
-
 end
 
-#----------------------------------------------
-# JRuby spec has a few more runtime dependencies
-#----------------------------------------------
-jruby_gemspec = This.gemspec['ruby'].dup
-jruby_gemspec.add_runtime_dependency( 'spoon', '~> 0.0.1' )
-jruby_gemspec.add_runtime_dependency( 'ffi'  , '~> 1.1.1' )
-jruby_gemspec.platform = 'java'
-This.gemspec['java']  = jruby_gemspec
-
-
-# The name of the gemspec file on disk
-This.gemspec_file = "#{This.name}.gemspec"
-
-# Really this is only here to support those who use bundler
-desc "Build the #{This.name}.gemspec file"
-task :gemspec do
-  File.open( This.gemspec_file, "wb+" ) do |f|
-    f.write Util.platform_gemspec.to_ruby
-  end
-end
-
-# the gemspec is also a dev artifact and should not be kept around.
-CLOBBER << This.gemspec_file
-
-# The standard gem packaging task, everyone has it.
-require 'rubygems/package_task'
-Gem::PackageTask.new( Util.platform_gemspec ) do
-  # nothing
+This.java_gemspec( This.ruby_gemspec ) do |spec|
+  spec.add_dependency( 'spoon', '~> 0.0.1' )
 end
 
-#------------------------------------------------------------------------------
-# Release - the steps we go through to do a final release, this is pulled from
-#           a compbination of mojombo's rakegem, hoe and hoe-git
-#
-# 1) make sure we are on the master branch
-# 2) make sure there are no uncommitted items
-# 3) check the manifest and make sure all looks good
-# 4) build the gem
-# 5) do an empty commit to have the commit message of the version
-# 6) tag that commit as the version
-# 7) push master
-# 8) push the tag
-# 7) pus the gem
-#------------------------------------------------------------------------------
-task :release_check do
-  unless `git branch` =~ /^\* master$/
-    abort "You must be on the master branch to release!"
-  end
-  unless `git status` =~ /^nothing to commit/m
-    abort "Nope, sorry, you have unfinished business"
-  end
-end
-
-desc "Create tag v#{This.version}, build and push #{Util.platform_gemspec.full_name} to rubygems.org"
-task :release => [ :release_check, 'manifest:check', :gem ] do
-  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
-  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
-  sh "git push origin master"
-  sh "git push origin v#{This.version}"
-  sh "gem push pkg/#{Util.platform_gemspec.full_name}.gem"
-end
-
-#------------------------------------------------------------------------------
-# Rakefile Support - This is all the guts and utility methods that are
-#                    necessary to support the above tasks.
-#
-# Lots of Credit for this Rakefile goes to:
-#
-#   Ara T. Howard       - see the Rakefile in all of his projects -
-#                          https://github.com/ahoward/
-#   Tom Preston Werner  - his Rakegem project https://github.com/mojombo/rakegem
-#   Seattle.rb          - Hoe - cuz it has relly good stuff in there
-#------------------------------------------------------------------------------
-BEGIN {
-
-  require 'ostruct'
-  require 'rake/clean'
-  require 'rubygems' unless defined? Gem
-
-  module Util
-    def self.version
-      [ "lib/#{ This.name }.rb", "lib/#{ This.name }/version.rb" ].each do |v|
-        line = File.read( v )[/^\s*VERSION\s*=\s*.*/]
-        if line then
-          return line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
-        end
-      end
-    end
-
-    # Partition an rdoc file into sections and return the text of the section
-    # as an array of paragraphs
-    def self.section_of( file, section_name )
-      re    = /^=+ (.*)$/
-      parts = File.read( file ).split( re )[1..-1]
-      parts.map! { |p| p.strip }
-
-      sections = Hash.new
-      Hash[*parts].each do |k,v|
-        sections[k] = v.split("\n\n")
-      end
-      return sections[section_name]
-    end
-
-    def self.task_warning( task )
-      warn "WARNING: '#{task}' tasks are not defined. Please run 'rake develop'"
-    end
-
-    def self.read_manifest
-      abort "You need a Manifest.txt" unless File.readable?( "Manifest.txt" )
-      File.readlines( "Manifest.txt" ).map { |l| l.strip }
-    end
-
-    def self.platform_gemspec
-      This.gemspec[This.platform]
-    end
-  end
-
-  # Hold all the metadata about this project
-  This = OpenStruct.new
-  This.platform = (RUBY_PLATFORM == "java") ? 'java' : Gem::Platform::RUBY
-
-  desc = Util.section_of( 'README.rdoc', 'DESCRIPTION')
-  This.summary     = desc.first
-  This.description = desc.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc
-
-
-  This.exclude_from_manifest = %r/tmp$|\.(git|DS_Store)|^(doc|coverage|pkg)|\.gemspec$|\.swp$|\.jar|\.rvmrc$|~$/
-  This.manifest = Util.read_manifest
-
-}
+load 'tasks/default.rake'

data/lib/launchy.rb

@@ -20,22 +20,33 @@ module Launchy
 
   class << self
     #
-    # Convenience method to launch an item
+    # Launch an application for the given uri string
     #
-    def open(uri, options = {} )
-      begin
-        extract_global_options( options )
-        uri = Addressable::URI.parse(  uri )
-        app = Launchy::Application.handling( uri )
-        app.new.open( uri, options )
-      rescue Exception => e
-        msg = "Failure in opening #{uri} with options #{options.inspect}: #{e}"
-        Launchy.log "#{self.name} : #{msg}"
-        e.backtrace.each do |bt|
-          Launchy.log bt
-        end
-        $stderr.puts msg
-      end
+    def open(uri_s, options = {} )
+      extract_global_options( options )
+      uri = string_to_uri( uri_s )
+      app = app_for_uri( uri )
+      app.new.open( uri, options )
+    rescue Launchy::Error => le
+      raise le
+    rescue Exception => e
+      msg = "Failure in opening uri #{uri_s.inspect} with options #{options.inspect}: #{e}"
+      raise Launchy::Error, msg
+    end
+
+    def app_for_uri( uri )
+      Launchy::Application.handling( uri )
+    end
+
+    def app_for_uri_string( s )
+      app_for_uri(  string_to_uri( s ) )
+    end
+
+    def string_to_uri( s )
+      uri = Addressable::URI.parse( s )
+      uri = Addressable::URI.heuristic_parse( s ) unless uri.scheme
+      raise Launchy::ArgumentError, "Invalid URI given: #{s.inspect}" unless uri
+      return uri
     end
 
     def reset_global_options

data/lib/launchy/cli.rb

@@ -57,14 +57,10 @@ module Launchy
     end
 
     def parse( argv, env )
-      begin
-        parser.parse!( argv )
-        return true
-      rescue ::OptionParser::ParseError => pe
-        $stderr.puts "#{parser.program_name}: #{pe}"
-        $stderr.puts "Try `#{parser.program_name} --help for more information."
-        return false
-      end
+      parser.parse!( argv )
+      return true
+    rescue ::OptionParser::ParseError => pe
+      error_output( pe )
     end
 
     def good_run( argv, env )
@@ -74,6 +70,18 @@ module Launchy
       else
         return false
       end
+    rescue StandardError => e
+      error_output( e )
+    end
+
+    def error_output( error )
+      $stderr.puts "ERROR: #{error}"
+      Launchy.log "ERROR: #{error}"
+      error.backtrace.each do |bt|
+        Launchy.log bt
+      end
+      $stderr.puts "Try `#{parser.program_name} --help' for more information."
+      return false
     end
 
     def run( argv = ARGV, env = ENV )

data/lib/launchy/detect/nix_desktop_environment.rb

@@ -2,7 +2,7 @@ module Launchy::Detect
   #
   # Detect the current desktop environment for *nix machines
   # Currently this is Linux centric. The detection is based upon the detection
-  # used by xdg-open from http://portland.freedesktop.org/wiki/XdgUtils
+  # used by xdg-open from http://portland.freedesktop.org/
   class NixDesktopEnvironment
     class NotFoundError < Launchy::Error; end
 
@@ -49,7 +49,7 @@ module Launchy::Detect
     class Xfce < NixDesktopEnvironment
       def self.is_current_desktop_environment?
         if Launchy::Application.find_executable( 'xprop' ) then
-          %x[ xprop -root _DT_SAVE_MODE | grep ' = \"xfce\"$' ].strip.size > 0
+          %x[ xprop -root _DT_SAVE_MODE].include?("xfce")
         else
           false
         end
@@ -59,6 +59,16 @@ module Launchy::Detect
         'exo-open'
       end
     end
+
+    class Fluxbox < NixDesktopEnvironment
+      def self.is_current_desktop_environment?
+        ENV['DESKTOP_SESSION'] == 'fluxbox'
+      end
+
+      def self.browser
+        'xdg-open'
+      end
+    end
   end
 end
 

data/lib/launchy/detect/runner.rb

@@ -25,7 +25,6 @@ module Launchy::Detect
 
       return Windows.new if host_os_family.windows?
       if ruby_engine.jruby? then
-        require 'spoon'
         return Jruby.new
       end
       return Forkable.new
@@ -95,6 +94,7 @@ module Launchy::Detect
 
     class Jruby < Runner
       def wet_run( cmd, *args )
+        require 'spoon'
         Spoon.spawnp( *shell_commands( cmd, *args ) )
       end
     end
@@ -102,11 +102,21 @@ module Launchy::Detect
     class Forkable < Runner
       def wet_run( cmd, *args )
         child_pid = fork do
+          close_file_descriptors unless Launchy.debug?
+          Launchy.log("wet_run: before exec in child process")
           exec( *shell_commands( cmd, *args ))
           exit!
         end
         Process.detach( child_pid )
       end
+
+      def close_file_descriptors
+        [$stdin, $stdout, $stderr].each do |io|
+          io.reopen( "/dev/null", "r+" )
+        end
+      end
+
+      private :close_file_descriptors
     end
   end
 end

data/lib/launchy/error.rb

@@ -2,4 +2,5 @@ module Launchy
   class Error < ::StandardError; end
   class ApplicationNotFoundError < Error; end
   class CommandNotFoundError < Error; end
+  class ArgumentError < Error; end
 end

data/lib/launchy/version.rb

@@ -1,5 +1,5 @@
 module Launchy
-  VERSION = "2.1.2"
+  VERSION = "2.2.0"
 
   module Version
 

data/spec/detect/nix_desktop_environment_spec.rb

@@ -22,6 +22,14 @@ describe Launchy::Detect::NixDesktopEnvironment do
     end
    end
 
+  it "detects the fluxbox desktop environment" do
+    ENV['DESKTOP_SESSION'] = 'fluxbox'
+    fluxbox_env = Launchy::Detect::NixDesktopEnvironment.detect
+    fluxbox_env.must_equal( Launchy::Detect::NixDesktopEnvironment::Fluxbox )
+    fluxbox_env.browser.must_equal( Launchy::Detect::NixDesktopEnvironment::Fluxbox.browser )
+    ENV.delete( 'DESKTOP_SESSION' )
+  end
+
   it "returns false for XFCE if xprop is not found" do
     Launchy.host_os = "linux"
     Launchy::Detect::NixDesktopEnvironment::Xfce.is_current_desktop_environment?.must_equal( false )

data/spec/launchy_spec.rb

@@ -50,9 +50,14 @@ describe Launchy do
     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/ )
+  it "raises an exception if no scheme is found for the given uri" do
+    lambda { Launchy.open( "blah://something/invalid" ) }.must_raise Launchy::ApplicationNotFoundError
   end
 
+  [ 'www.example.com', 'www.example.com/foo/bar' ].each do |x|
+    it "picks a Browser for #{x}" do
+      app = Launchy.app_for_uri_string( x )
+      app.must_equal( Launchy::Application::Browser )
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,9 @@
+if RUBY_VERSION >= '1.9.2' then
+  require 'simplecov'
+  puts "Using coverage!"
+  SimpleCov.start if ENV['COVERAGE']
+end
+
 gem 'minitest'
 require 'launchy'
 require 'stringio'

data/tasks/default.rake

@@ -0,0 +1,213 @@
+# vim: syntax=ruby
+require 'rake/clean'
+#------------------------------------------------------------------------------
+# If you want to Develop on this project just run 'rake develop' and you'll
+# have all you need to get going. If you want to use bundler for development,
+# then run 'rake develop:using_bundler'
+#------------------------------------------------------------------------------
+namespace :develop do
+
+  # Install all the development and runtime dependencies of this gem using the
+  # gemspec.
+  task :default do
+    require 'rubygems/dependency_installer'
+    installer = Gem::DependencyInstaller.new
+
+    This.set_coverage_gem
+
+    puts "Installing gem depedencies needed for development"
+    This.platform_gemspec.dependencies.each do |dep|
+      if dep.matching_specs.empty? then
+        puts "Installing : #{dep}"
+        installer.install dep
+      else
+        puts "Skipping   : #{dep} -> already installed #{dep.matching_specs.first.full_name}"
+      end
+    end
+    puts "\n\nNow run 'rake test'"
+  end
+
+  # Create a Gemfile that just references the gemspec
+  file 'Gemfile' => :gemspec do
+    File.open( "Gemfile", "w+" ) do |f|
+      f.puts 'source :rubygems'
+      f.puts 'gemspec'
+    end
+  end
+
+  desc "Create a bundler Gemfile"
+  task :using_bundler => 'Gemfile' do
+    puts "Now you can 'bundle'"
+  end
+
+  # Gemfiles are build artifacts
+  CLOBBER << FileList['Gemfile*']
+end
+desc "Boostrap development"
+task :develop => "develop:default"
+
+#------------------------------------------------------------------------------
+# Minitest - standard TestTask
+#------------------------------------------------------------------------------
+begin
+  require 'rake/testtask'
+  Rake::TestTask.new( :test ) do |t|
+    t.ruby_opts    = %w[ -w -rubygems ]
+    t.libs         = %w[ lib spec ]
+    t.pattern      = "spec/**/*_spec.rb"
+  end
+  task :default => :test
+rescue LoadError
+  This.task_warning( 'test' )
+end
+
+#------------------------------------------------------------------------------
+# RDoc - standard rdoc rake task, although we must make sure to use a more
+#        recent version of rdoc since it is the one that has 'tomdoc' markup
+#------------------------------------------------------------------------------
+begin
+  gem 'rdoc' # otherwise we get the wrong task from stdlib
+  require 'rdoc/task'
+  RDoc::Task.new do |t|
+    t.markup   = 'tomdoc'
+    t.rdoc_dir = 'doc'
+    t.main     = 'README.rdoc'
+    t.title    = "#{This.name} #{This.version}"
+    t.rdoc_files.include( '*.rdoc', 'lib/**/*.rb' )
+  end
+rescue LoadError => le
+  This.task_warning( 'rdoc' )
+end
+
+#------------------------------------------------------------------------------
+# Coverage - optional code coverage, rcov for 1.8 and simplecov for 1.9, so
+#            for the moment only rcov is listed.
+#------------------------------------------------------------------------------
+if RUBY_VERSION < "1.9.0"
+  begin
+   require 'rcov/rcovtask'
+   Rcov::RcovTask.new( 'coverage' ) do |t|
+     t.libs      << 'spec'
+     t.pattern   = 'spec/**/*_spec.rb'
+     t.verbose   = true
+     t.rcov_opts << "-x ^/"           # remove all the global files
+     t.rcov_opts << "--sort coverage" # so we see the worst files at the top
+   end
+  rescue LoadError
+   This.task_warning( 'rcov' )
+  end
+else
+  begin
+    require 'simplecov'
+    desc 'Run tests with code coverage'
+    task :coverage do
+      ENV['COVERAGE'] = 'true'
+      Rake::Task[:test].execute
+    end
+    CLOBBER << FileList["coverage"]
+  rescue LoadError
+    This.task_warning( 'simplecov' )
+  end
+end
+
+#------------------------------------------------------------------------------
+# Manifest - We want an explicit list of thos files that are to be packaged in
+#            the gem. Most of this is from Hoe.
+#------------------------------------------------------------------------------
+namespace 'manifest' do
+  desc "Check the manifest"
+  task :check => :clean do
+    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
+    files = files.select{ |f| File.file?( f ) }
+
+    tmp = "Manifest.tmp"
+    File.open( tmp, 'w' ) do |f|
+      f.puts files.join("\n")
+    end
+
+    begin
+      sh "diff -du Manifest.txt #{tmp}"
+    ensure
+      rm tmp
+    end
+    puts "Manifest looks good"
+  end
+
+  desc "Generate the manifest"
+  task :generate => :clean do
+    files = %x[ git ls-files ].split("\n").sort
+    files.reject! { |f| f =~ This.exclude_from_manifest }
+    File.open( "Manifest.txt", "w" ) do |f|
+      f.puts files.join("\n")
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# Fixme - look for fixmes and report them
+#------------------------------------------------------------------------------
+desc "Look for fixmes and report them"
+task :fixme => 'manifest:check' do
+  This.manifest.each do |file|
+    next if file == File.basename( __FILE__ )
+
+    puts "FIXME: Rename #{file}" if file =~ /fixme/i
+
+    IO.readlines( file ).each_with_index do |line, idx|
+      prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
+      puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# Gem Specification
+#------------------------------------------------------------------------------
+# Really this is only here to support those who use bundler
+desc "Build the #{This.name}.gemspec file"
+task :gemspec do
+  File.open( This.gemspec_file, "wb+" ) do |f|
+    f.write This.platform_gemspec.to_ruby
+  end
+end
+
+# the gemspec is also a dev artifact and should not be kept around.
+CLOBBER << This.gemspec_file
+
+# The standard gem packaging task, everyone has it.
+require 'rubygems/package_task'
+Gem::PackageTask.new( This.platform_gemspec ) do
+  # nothing
+end
+
+#------------------------------------------------------------------------------
+# Release - the steps we go through to do a final release, this is pulled from
+#           a compbination of mojombo's rakegem, hoe and hoe-git
+#
+# 1) make sure we are on the master branch
+# 2) make sure there are no uncommitted items
+# 3) check the manifest and make sure all looks good
+# 4) build the gem
+# 5) do an empty commit to have the commit message of the version
+# 6) tag that commit as the version
+# 7) push master
+# 8) push the tag
+# 7) pus the gem
+#------------------------------------------------------------------------------
+task :release_check do
+  unless `git branch` =~ /^\* master$/
+    abort "You must be on the master branch to release!"
+  end
+  unless `git status` =~ /^nothing to commit/m
+    abort "Nope, sorry, you have unfinished business"
+  end
+end
+
+desc "Create tag v#{This.version}, build and push #{This.platform_gemspec.full_name} to rubygems.org"
+task :release => [ :release_check, 'manifest:check', :gem ] do
+  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
+  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
+  sh "git push origin master"
+  sh "git push origin v#{This.version}"
+  sh "gem push pkg/#{This.platform_gemspec.full_name}.gem"
+end

data/tasks/this.rb

@@ -0,0 +1,202 @@
+require 'pathname'
+
+# Public: A Class containing all the metadata and utilities needed to manage a
+# ruby project.
+class ThisProject
+  # The name of this project
+  attr_accessor :name
+
+  # The author's name
+  attr_accessor :author
+
+  # The email address of the author(s)
+  attr_accessor :email
+
+  # The homepage of this project
+  attr_accessor :homepage 
+
+  # The regex of files to exclude from the manifest
+  attr_accessor :exclude_from_manifest
+
+  # The hash of Gem::Specifications keyed' by platform
+  attr_accessor :gemspecs
+
+  # Public: Initialize ThisProject
+  #
+  # Yields self
+  def initialize(&block)
+    @exclude_from_manifest = %r/tmp$|\.(git|DS_Store)|^(doc|coverage|pkg)|Gemfile*|\.gemspec$|\.swp$|\.jar|\.rvmrc$|~$/
+    @gemspecs              = Hash.new
+    yield self if block_given?
+  end
+
+  # Public: return the version of ThisProject
+  #
+  # Search the ruby files in the project looking for the one that has the
+  # version string in it. This does not eval any code in the project, it parses
+  # the source code looking for the string.
+  #
+  # Returns a String version
+  def version
+    [ "lib/#{ name }.rb", "lib/#{ name }/version.rb" ].each do |v|
+      path = project_path( v )
+      line = path.read[/^\s*VERSION\s*=\s*.*/]
+      if line then
+        return line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+      end
+    end
+  end
+
+  # Internal: Return a section of an RDoc file with the given section name
+  #
+  # path         - the relative path in the project of the file to parse
+  # section_name - the section out of the file from which to parse data
+  #
+  # Retuns the text of the section as an array of paragrphs.
+  def section_of( file, section_name )
+    re    = /^=+ (.*)$/
+    sectional = project_path( file )
+    parts = sectional.read.split( re )[1..-1]
+    parts.map! { |p| p.strip }
+
+    sections = Hash.new
+    Hash[*parts].each do |k,v|
+      sections[k] = v.split("\n\n")
+    end
+    return sections[section_name]
+  end
+
+  # Internal: print out a warning about the give task
+  def task_warning( task )
+    warn "WARNING: '#{task}' tasks are not defined. Please run 'rake develop'"
+  end
+
+  # Internal: Return the full path to the file that is relative to the project
+  # root.
+  #
+  # path - the relative path of the file from the project root
+  #
+  # Returns the Pathname of the file
+  def project_path( relative_path )
+    project_root.join( relative_path )
+  end
+
+  # Internal: The absolute path of this file
+  #
+  # Returns the Pathname of this file.
+  def this_file_path
+    Pathname.new( __FILE__ ).expand_path
+  end
+
+  # Internal: The root directory of this project
+  #
+  # This is defined as being the directory that is in the path of this project
+  # that has the first Rakefile
+  #
+  # Returns the Pathname of the directory
+  def project_root
+    this_file_path.ascend do |p|
+      rakefile = p.join( 'Rakefile' )
+      return p if rakefile.exist?
+    end
+  end
+
+  # Internal: Returns the contents of the Manifest.txt file as an array
+  #
+  # Returns an Array of strings
+  def manifest
+    manifest_file = project_path( "Manifest.txt" )
+    abort "You need a Manifest.txt" unless manifest_file.readable?
+    manifest_file.readlines.map { |l| l.strip }
+  end
+
+  # Internal: Returns the gemspace associated with the current ruby platform
+  def platform_gemspec
+    gemspecs[platform]
+  end
+
+  def core_gemspec
+    Gem::Specification.new do |spec|
+      spec.name        = name
+      spec.version     = version
+      spec.author      = author
+      spec.email       = email
+      spec.homepage    = homepage
+
+      spec.summary     = summary
+      spec.description = description
+
+      spec.files       = manifest
+      spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
+      spec.test_files  = spec.files.grep(/^spec/)
+
+      spec.extra_rdoc_files += spec.files.grep(/(txt|rdoc)$/)
+      spec.rdoc_options = [ "--main"  , 'README.rdoc',
+                            "--markup", "tomdoc" ]
+    end
+  end
+
+  # Internal: Return the gemspec for the ruby platform
+  def ruby_gemspec( core = core_gemspec, &block )
+    yielding_gemspec( 'ruby', core, &block )
+  end
+
+  # Internal: Return the gemspec for the jruby platform
+  def java_gemspec( core = core_gemspec, &block )
+    yielding_gemspec( 'java', core, &block )
+  end
+
+  # Internal: give an initial spec and a key, create a new gemspec based off of
+  # it.
+  #
+  # This will force the new gemspecs 'platform' to be that of the key, since the
+  # only reason you would have multiple gemspecs at this point is to deal with
+  # different platforms.
+  def yielding_gemspec( key, core )
+    spec = gemspecs[key] ||= core.dup
+    spec.platform = key
+    yield spec if block_given?
+    return spec
+  end
+
+  # Internal: Set the recovery gem development dependency
+  #
+  # These are dynamically set since they cannot be hard coded as there is 
+  # no way to ship them correctly in the gemspec
+  #
+  # Returns nothing.
+  def set_coverage_gem
+    if RUBY_VERSION < "1.9.0"
+      platform_gemspec.add_development_dependency( 'rcov', '~> 1.0.0' )
+    else
+      platform_gemspec.add_development_dependency( 'simplecov', '~> 0.7.1' )
+    end
+  end
+
+  # Internal: Return the platform of ThisProject at the current moment in time.
+  def platform
+    (RUBY_PLATFORM == "java") ? 'java' : Gem::Platform::RUBY
+  end
+
+  # Internal: Return the DESCRIPTION section of the README.rdoc file
+  def description_section
+    section_of( 'README.rdoc', 'DESCRIPTION')
+  end
+ 
+ # Internal: Return the summary text from the README 
+  def summary
+    description_section.first
+  end
+
+  # Internal: Return the full description text from the READEM
+  def description
+    description_section.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc
+  end
+
+  # Internal: The path to the gemspec file
+  def gemspec_file
+    project_path( "#{ name }.gemspec" )
+  end
+end
+
+This = ThisProject.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: launchy
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-06 00:00:00.000000000 Z
+date: 2013-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.2.2
+        version: 10.0.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.2.2
+        version: 10.0.3
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: 4.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: 4.5.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -75,38 +75,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.12'
-- !ruby/object:Gem::Dependency
-  name: spoon
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.0.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.0.1
-- !ruby/object:Gem::Dependency
-  name: ffi
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.1.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.1.1
 description: Launchy is helper class for launching cross-platform applications in
   a fire and forget manner. There are application concepts (browser, email client,
   etc) that are common across all platforms, and they may be launched differently
@@ -121,10 +89,10 @@ extra_rdoc_files:
 - Manifest.txt
 - README.rdoc
 files:
+- CONTRIBUTING.md
 - HISTORY.rdoc
 - LICENSE
 - Manifest.txt
-- NOTES
 - README.rdoc
 - Rakefile
 - bin/launchy
@@ -156,12 +124,16 @@ files:
 - spec/spec_helper.rb
 - spec/tattle-host-os.yaml
 - spec/version_spec.rb
+- tasks/default.rake
+- tasks/this.rb
 homepage: http://github.com/copiousfreetime/launchy
 licenses: []
 post_install_message: 
 rdoc_options:
 - --main
 - README.rdoc
+- --markup
+- tomdoc
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement

data/NOTES

@@ -1 +0,0 @@
-* Allow for new tab/ new window for opening a browser