launchy 0.4.0 → 2.0.0

data/.autotest

@@ -0,0 +1,28 @@
+# 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
+

data/HISTORY

@@ -1,5 +1,20 @@
 = Launchy Changlog
 
+== Version 2.0.0 - 2011-07-16
+
+* Almost a complete rewrite
+* JRuby Support
+* Organization is such that it will be easier to add additional applications
+* Windows behavior possibly fixed, again
+
+== Version 1.0.0 - 2011-03-17
+
+* Add JRuby support (Stephen Judkins)
+* Remove unused Paths module
+* Switch to using bones
+* Switch to use minitest
+* NOTE, this version was never released.
+
 == Version 0.4.0 - 2011-01-27
 
 * Add support for file:/// schema (postmodern)

data/LICENSE

@@ -1,6 +1,6 @@
 ISC LICENSE - http://opensource.org/licenses/isc-license.txt
 
-Copyright (c) 2007-2009 Jeremy Hinegardner
+Copyright (c) 2007-2011 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/NOTES

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

data/README

@@ -1,7 +1,7 @@
 == launchy
 
-* Homepage[http://copiousfreetime.rubyforge.org/launchy/]
-* {Rubyforge Project}[http://rubyforge.org/projects/copiousfreetime]
+* Homepage[http://www.copiousfreetime.org/projects/launchy/]
+* {Github Project}[http://github.com/copiousfreetime/launchy]
 * email jeremy at hinegardner dot org
 
 == DESCRIPTION
@@ -11,7 +11,7 @@ fire and forget manner.
 
 There are application concepts (browser, email client, etc) that are
 common across all platforms, and they may be launched differently on
-each platform.  Launchy is here to make a common approach to launching
+each platform. Launchy is here to make a common approach to launching
 external application from within ruby programs.
 
 == FEATURES
@@ -26,17 +26,17 @@ From within your ruby code you can trust launchy to do the right thing:
 
 Or, if you want to launch the application yourself:
 
-    Launchy::Browser.run("http://www.ruby-lang.org/")
+    Launchy::Browser.open("http://www.ruby-lang.org/")
 
 OR
 
-    Launchy::Browser.new.visit("http://www.ruby-lang.org/")
+    Launchy::Browser.new.open("http://www.ruby-lang.org/")
 
 == ISC LICENSE
 
 http://opensource.org/licenses/isc-license.txt
 
-Copyright (c) 2007-2009 Jeremy Hinegardner
+Copyright (c) 2007-2011 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

@@ -3,60 +3,56 @@
 # All rights reserved.  See LICENSE and/or COPYING for details.
 #++
 
-#-------------------------------------------------------------------------------
-# make sure our project's top level directory and the lib directory are added to
-# the ruby search path.
-#-------------------------------------------------------------------------------
-$: << File.expand_path(File.join(File.dirname(__FILE__),"lib"))
-$: << File.expand_path(File.dirname(__FILE__))
-
-
-#-------------------------------------------------------------------------------
-# load the global project configuration and add in the top level clean and
-# clobber tasks so that other tasks can utilize those constants if necessary
-# This loads up the defaults for the whole project configuration
-#-------------------------------------------------------------------------------
-require 'rubygems'
-require 'tasks/config.rb'
-require 'rake/clean'
-
-#-------------------------------------------------------------------------------
-# Main configuration for the project, these overwrite the items that are in
-# tasks/config.rb
-#-------------------------------------------------------------------------------
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'test:run'
+task 'gem:release' => 'test:run'
+
+$:.unshift( "lib" )
 require 'launchy/version'
-require 'launchy/paths'
 
-Configuration.for("project") {
+Bones {
   name      "launchy"
-  version   Launchy::VERSION
-  author    "Jeremy Hinegardner"
+  authors   "Jeremy Hinegardner"
   email     "jeremy@copiousfreetime.org"
-  homepage  "http://copiousfreetime.rubyforge.org/launchy/"
-}
+  url       'http://www.copiousfreetime.org/projects/launchy'
+  version   Launchy::VERSION
 
-#-------------------------------------------------------------------------------
-# load up all the project tasks and setup the default task to be the
-# test:default task.
-#-------------------------------------------------------------------------------
-Configuration.for("packaging").files.tasks.each do |tasklib|
-  import tasklib
-end
-task :default => 'test:default'
-
-#-------------------------------------------------------------------------------
-# Finalize the loading of all pending imports and update the top level clobber
-# task to depend on all possible sub-level tasks that have a name like
-# ':clobber'  in other namespaces.  This allows us to say:
-#
-#   rake clobber
-#
-# and it will get everything.
-#-------------------------------------------------------------------------------
-Rake.application.load_imports
-Rake.application.tasks.each do |t| 
-  if t.name =~ /:clobber/ then
-    task :clobber => [t.name] 
-  end 
-end
+  ruby_opts     %w[ -W0 -rubygems ]
+  readme_file   'README'
+  ignore_file   '.gitignore'
+  history_file  'HISTORY'
 
+  rdoc.include << "README" << "HISTORY" << "LICENSE"
+
+  summary 'Launchy is helper class for launching cross-platform applications in a fire and forget manner.'
+  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 on
+each platform.  Launchy is here to make a common approach to launching
+external application from within ruby programs.
+_
+
+  if RUBY_PLATFORM == "java" then
+    depend_on "spoon"   , "~> 0.0.1"
+    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
+
+  if defined?( RUBY_ENGINE ) and RUBY_ENGINE == "jruby" then
+    depend_on 'spoon'   , "~> 0.0.1"
+  end
+
+  test.files = FileList["spec/**/*_spec.rb"]
+  test.opts << "-w -Ilib:spec"
+}

data/bin/launchy

@@ -1,12 +1,4 @@
 #!/usr/bin/env ruby
 
-begin
-    require 'launchy'
-rescue LoadError 
-    path = File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
-    raise if $:.include? path
-    $: << path
-    retry
-end
-
-Launchy.command_line.run(ARGV)
+require 'launchy'
+Launchy::Cli.new.run( ARGV, ENV )

data/lib/launchy.rb

@@ -1,53 +1,119 @@
+require 'uri'
+
+#
+# Top level entry point into Launchy. Almost everyone will just use the single
+# call:
+#
+#   Launchy.open( uri, options = {} )
+#
+# The currently defined global 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
+#
+# Other options may be used, and those will be passed directly to the
+# application class
+#
 module Launchy
-  #
-  # Utility method to require all files ending in .rb in the directory
-  # with the same name as this file minus .rb
-  #
-  def self.require_all_libs_relative_to(fname)
-    prepend   = File.basename(fname,".rb")
-    search_me = File.join(File.dirname(fname),prepend)
-
-    Dir.entries(search_me).each do |rb|
-      if File.extname(rb) == ".rb" then
-        require "#{prepend}/#{File.basename(rb,".rb")}"
-      end
-    end
-  end
 
   class << self
     #
     # Convenience method to launch an item
     #
-    def open(*params)
+    def open(uri, options = {} )
       begin
-        klass = Launchy::Application.find_application_class_for(*params)
-        if klass then
-          klass.run(*params)
+        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 #{params.join(' ')}"
+          msg = "Unable to launch #{uri} with options #{options.inspect}"
           Launchy.log "#{self.name} : #{msg}"
           $stderr.puts msg
         end
       rescue Exception => e
-        msg = "Failure in opening #{params.join(' ')} : #{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
     end
 
-    # Setting the LAUNCHY_DEBUG environment variable to 'true' will spew
-    # debug information to $stderr
-    def log(msg)
-      if ENV['LAUNCHY_DEBUG'] == 'true' then
-        $stderr.puts "LAUNCHY_DEBUG: #{msg}"
-      end
+    def reset_global_options
+      Launchy.debug       = false
+      Launchy.application = nil
+      Launchy.host_os     = nil
+      Launchy.ruby_engine = nil
+      Launchy.dry_run     = false
+    end
+
+    def extract_global_options( options )
+      Launchy.debug        = options.delete( :debug       ) || ENV['LAUNCHY_DEBUG']
+      Launchy.application  = options.delete( :application ) || ENV['LAUNCHY_APPLICATION']
+      Launchy.host_os      = options.delete( :host_os     ) || ENV['LAUNCHY_HOST_OS']
+      Launchy.ruby_engine  = options.delete( :ruby_engine ) || ENV['LAUNCHY_RUBY_ENGINE']
+      Launchy.dry_run      = options.delete( :dry_run     )
+    end
+
+    def debug=( d )
+      @debug = (d == "true")
+    end
+
+    # we may do logging before a call to 'open', hence the need to check
+    # LAUNCHY_DEBUG here
+    def debug?
+      @debug || (ENV['LAUNCHY_DEBUG'] == 'true')
+    end
+
+    def application=( app )
+      @application = app
+    end
+
+    def application
+      @application || ENV['LAUNCHY_APPLICATION']
+    end
+
+    def host_os=( host_os )
+      @host_os = host_os
+    end
+
+    def host_os
+      @host_os || ENV['LAUNCHY_HOST_OS']
+    end
+
+    def ruby_engine=( ruby_engine )
+      @ruby_engine = ruby_engine
+    end
+
+    def ruby_engine
+      @ruby_engine || ENV['LAUNCHY_RUBY_ENGINE']
+    end
+
+    def dry_run=( dry_run )
+      @dry_run = dry_run
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    def bug_report_message
+      "Please file a bug at https://github.com/copiousfreetime/launchy/issues/new"
     end
 
-    # Create an instance of the commandline application of launchy
-    def command_line
-      Launchy::CommandLine.new
+    def log(msg)
+      $stderr.puts "LAUNCHY_DEBUG: #{msg}" if Launchy.debug?
     end
   end
 end
 
-Launchy.require_all_libs_relative_to(__FILE__)
+require 'launchy/version'
+require 'launchy/cli'
+require 'launchy/descendant_tracker'
+require 'launchy/error'
+require 'launchy/application'
+require 'launchy/detect'

data/lib/launchy/application.rb

@@ -1,178 +1,81 @@
-require 'rbconfig'
-
+require 'set'
 module Launchy
+  #
+  # Application is the base class of all the application types that launchy may
+  # invoke. It essentially defines the public api of the launchy system.
+  #
+  # Every class that inherits from Application must define:
+  #
+  # 1. A constructor taking no parameters
+  # 2. An instance method 'open' taking a string or URI as the first parameter and a
+  #    hash as the second
+  # 3. A class method 'schemes' that returns an array of Strings containing the
+  #    schemes that the Application will handle
   class Application
+    extend DescendantTracker
+
     class << self
-      def known_os_families
-        @known_os_families ||= [ :windows, :darwin, :nix, :cygwin, :testing ]
+      #
+      # The list of all the schemes all the applications know
+      #
+      def scheme_list
+        children.collect { |a| a.schemes }.flatten.sort
       end
 
-      def inherited(sub_class)
-        application_classes << sub_class
-      end
-      def application_classes
-        @application_classes ||= []
+      #
+      # if this application handles the given scheme
+      #
+      def handles?( scheme )
+        schemes.include?( scheme )
       end
 
-      def find_application_class_for(*args)
-        Launchy.log "#{self.name} : finding application classes for [#{args.join(' ')}]"
-        application_classes.find do |klass|
-          Launchy.log "#{self.name} : Trying #{klass.name}"
-          if klass.handle?(*args) then
-            true
-          else
-            false
-          end
+      #
+      # Find the application that handles the given scheme.  May take either a
+      # String or something that responds_to?( :scheme )
+      #
+      def for_scheme( scheme )
+        if scheme.respond_to?( :scheme ) then
+          scheme = scheme.scheme
         end
+
+        klass = find_child( :handles?, scheme )
+        return klass if klass
+
+        raise SchemeNotFoundError, "No application found to handle scheme '#{scheme}'. Known schemes: #{scheme_list.join(", ")}"
       end
 
-      # find an executable in the available paths
-      # mkrf did such a good job on this I had to borrow it.
-      def find_executable(bin,*paths)
-        paths = ENV['PATH'].split(File::PATH_SEPARATOR) if paths.empty?
+      #
+      # Find the given executable in the available paths
+      def find_executable( bin, *paths )
+        paths = ENV['PATH'].split( File::PATH_SEPARATOR ) if paths.empty?
         paths.each do |path|
-          file = File.join(path,bin)
-          if File.executable?(file) then
+          file = File.join( path, bin )
+          if File.executable?( file ) then
             Launchy.log "#{self.name} : found executable #{file}"
             return file
           end
         end
-        Launchy.log "#{self.name} : Unable to find `#{bin}' in #{paths.join(', ')}"
+        Launchy.log "#{self.name} : Unable to find `#{bin}' in #{paths.join(", ")}"
         return nil
       end
-
-      # return the current 'host_os' string from ruby's configuration
-      def my_os
-        if ENV['LAUNCHY_HOST_OS'] then
-          Launchy.log "#{self.name} : Using LAUNCHY_HOST_OS override of '#{ENV['LAUNCHY_HOST_OS']}'"
-          return ENV['LAUNCHY_HOST_OS']
-        else
-          ::Config::CONFIG['host_os']
-        end
-      end
-
-      # detect what the current os is and return :windows, :darwin or :nix
-      def my_os_family(test_os = my_os)
-        case test_os
-        when /mingw/i
-          family = :windows
-        when /mswin/i
-          family = :windows
-        when /windows/i
-          family = :windows
-        when /darwin/i
-          family = :darwin
-        when /mac os/i
-          family = :darwin
-        when /solaris/i
-          family = :nix
-        when /bsd/i
-          family = :nix
-        when /linux/i
-          family = :nix
-        when /aix/i
-          family = :nix
-        when /cygwin/i
-          family = :cygwin
-        when /testing/i
-          family = :testing
-        else
-          $stderr.puts "Unknown OS familiy for '#{test_os}'.  Please report this bug to <jeremy at hinegardner dot org>"
-          family = :unknown
-        end
-      end
     end
 
-
-    # Determine the appropriate desktop environment for *nix machine.  Currently this is
-    # linux centric.  The detection is based upon the detection used by xdg-open from
-    # http://portland.freedesktop.org/wiki/XdgUtils
-    def nix_desktop_environment
-      if not defined? @nix_desktop_environment then
-        @nix_desktop_environment = :generic
-        if ENV["KDE_FULL_SESSION"] || ENV["KDE_SESSION_UID"] then
-          @nix_desktop_environment = :kde
-        elsif ENV["GNOME_DESKTOP_SESSION_ID"] then
-          @nix_desktop_environment = :gnome
-        elsif find_executable("xprop") then
-          if %x[ xprop -root _DT_SAVE_MODE | grep ' = \"xfce\"$' ].strip.size > 0 then
-            @nix_desktop_environment = :xfce
-          end
-        end
-        Launchy.log "#{self.class.name} : nix_desktop_environment => '#{@nix_desktop_environment}'"
-      end
-      return @nix_desktop_environment
+    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
+      @runner         = Launchy::Detect::Runner.detect
     end
 
-    # find an executable in the available paths
-    def find_executable(bin,*paths)
-      Application.find_executable(bin,*paths)
+    def find_executable( bin, *paths )
+      Application.find_executable( bin, *paths )
     end
 
-    # return the current 'host_os' string from ruby's configuration
-    def my_os
-      Application.my_os
-    end
-
-    # detect what the current os is and return :windows, :darwin, :nix, or :cygwin
-    def my_os_family(test_os = my_os)
-      Application.my_os_family(test_os)
-    end
-
-    # returns the list of command line application names for the current os.  The list
-    # returned should only contain appliations or commands that actually exist on the
-    # system.  The list members should have their full path to the executable.
-    def app_list
-      @app_list ||= self.send("#{my_os_family}_app_list")
-    end
-
-    # On darwin a good general default is the 'open' executable.
-    def darwin_app_list
-      Launchy.log "#{self.class.name} : Using 'open' application on darwin."
-      [ find_executable('open') ]
-    end
-
-    # On windows a good general default is the 'start' Command Shell command
-    def windows_app_list
-      Launchy.log "#{self.class.name} : Using 'start' command on windows."
-      %w[ start ]
-    end
-
-    # Cygwin uses the windows start but through an explicit execution of the cmd shell
-    def cygwin_app_list
-      Launchy.log "#{self.class.name} : Using 'cmd /C start' on windows."
-      [ "cmd /C start" ]
-    end
-
-    # used only for running tests
-    def testing_app_list
-      []
-    end
-
-    # run the command
-    def run(cmd,*args)
-      Launchy.log "#{self.class.name} : Spawning on #{my_os_family} : #{cmd} #{args.inspect}"
-
-      if my_os_family == :windows then
-        # NOTE: the command is purposely omitted here because
-        #       When "cmd /c start filename" is
-        #       run, the shell interprets it as two commands:
-        #       (1) "start" opens a new terminal, and (2)
-        #       "filename" causes the file to be launched.
-        system 'cmd', '/c', cmd, *args
-      else
-        # fork, and the child process should NOT run any exit handlers
-        child_pid = fork do
-          # NOTE: we pass a dummy argument *before*
-          #       the actual command to prevent sh
-          #       from silently consuming our actual
-          #       command and assigning it to $0!
-          dummy = ''
-          system 'sh', '-c', '"$@" >/dev/null 2>&1', dummy, cmd, *args
-          exit!
-        end
-        Process.detach(child_pid)
-      end
+    def run( cmd, *args )
+      runner.run( cmd, *args )
     end
   end
 end
+require 'launchy/applications/browser'