launchy 0.3.2 → 0.3.3

data/{CHANGES → HISTORY}

@@ -1,25 +1,32 @@
-== Changes
-=== Version 0.3.2 - 2008-05-21
+= Launchy Changlog
+
+== Version 0.3.3 - 2009-02-19
+
+* pass command line as discrete items to system() to avoid string
+  interpretation by the system shell. (Suraj N. Kurapati)
+* rework project layout and tasks
+
+== Version 0.3.2 - 2008-05-21
 
 * detect aix and mingw as known operating systems.
 
-=== Version 0.3.1 - 2007-09-08
+== Version 0.3.1 - 2007-09-08
 
 * finalize the command line wrapper around the launchy library.
 * added more tests
 
-=== Version 0.3.0 - 2007-08-30
+== Version 0.3.0 - 2007-08-30
 
 * reorganize the code structure, removing Spawnable namespace
 * removed 'do_magic' method, changed it to 'open'
 * added override environment variable LAUNCHY_HOST_OS for testing
 * fix broken cygwin support [Bug #13472]
 
-=== Version 0.2.1 - 2007-08-18
+== Version 0.2.1 - 2007-08-18
 
 * fix inability to find windows executables [Bug #13132]
 
-=== Version 0.2.0 - 2007-08-11
+== Version 0.2.0 - 2007-08-11
 
 * rework browser finding
 * manual override with LAUNCHY_BROWSER environment variable
@@ -28,23 +35,23 @@
 * removed win32 gem
 * Add debug output by setting LAUNCHY_DEBUG environment variable to 'true'
 
-=== Version 0.1.2 - 2007-08-11
+== Version 0.1.2 - 2007-08-11
 
 * forked child exits without calling at_exit handlers
 
-=== Version 0.1.1
+== Version 0.1.1
 
 * fixed rubyforge task to release mswin32 gem also
 
-=== Version 0.1.0 
+== Version 0.1.0 
 
 * Initial public release
 * switched to using fork to spawn process and require 'win32/process' if on windows
 
-=== Version 0.0.2
+== Version 0.0.2
 
 * First attempt at using systemu to spawn processes
 
-=== Version 0.0.1
+== Version 0.0.1
 
 * Initially working release

data/README

@@ -7,11 +7,11 @@
 == DESCRIPTION
 
 Launchy is helper class for launching cross-platform applications in a
-fire and forget manner.  
+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
+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.
 
 == FEATURES
@@ -32,36 +32,18 @@ OR
 
     Launchy::Browser.new.visit("http://www.ruby-lang.org/")
 
-== LICENSE
-
-Copyright (c) 2007, Jeremy Hinegardner
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
- 
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the
-      distribution.  
-      
-    * Neither the name of Jeremy Hinegardner nor the
-      names of its contributors may be used to endorse or promote
-      products derived from this software without specific prior written
-      permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+== ISC LICENSE
+
+Copyright (c) 2007-2009 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
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/Rakefile

@@ -0,0 +1,62 @@
+#--
+# Copyright (c) 2007 Jeremy Hinegardner
+# 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
+#-------------------------------------------------------------------------------
+require 'launchy/version'
+require 'launchy/paths'
+
+Configuration.for("project") {
+  name      "launchy"
+  version   Launchy::VERSION
+  author    "Jeremy Hinegardner"
+  email     "jeremy@copiousfreetime.org"
+  homepage  "http://copiousfreetime.rubyforge.org/launchy/"
+}
+
+#-------------------------------------------------------------------------------
+# 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
+

data/gemspec.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'launchy/version'
+require 'tasks/config'
+
+Launchy::GEM_SPEC = Gem::Specification.new do |spec|
+  proj = Configuration.for('project')
+  spec.name         = proj.name
+  spec.version      = Launchy::VERSION
+
+  spec.author       = proj.author
+  spec.email        = proj.email
+  spec.homepage     = proj.homepage
+  spec.summary      = proj.summary
+  spec.description  = proj.description
+  spec.platform     = Gem::Platform::RUBY
+
+
+  pkg = Configuration.for('packaging')
+  spec.files        = pkg.files.all
+  spec.executables  = pkg.files.bin.collect { |b| File.basename(b) }
+
+  # add dependencies here
+  spec.add_dependency("rake", ">= 0.8.1")
+  spec.add_dependency("configuration", ">= 0.0.5")
+
+  if rdoc = Configuration.for_if_exist?('rdoc') then
+    spec.has_rdoc         = true
+    spec.extra_rdoc_files = pkg.files.rdoc
+    spec.rdoc_options     = rdoc.options + [ "--main" , rdoc.main_page ]
+  else
+    spec.has_rdoc         = false
+  end
+
+  if test = Configuration.for_if_exist?('testing') then
+    spec.test_files       = test.files
+  end
+
+  if rf = Configuration.for_if_exist?('rubyforge') then
+    spec.rubyforge_project  = rf.project
+  end
+end

data/lib/launchy.rb

@@ -1,58 +1,53 @@
 module Launchy
-    
-    ROOT_DIR        = File.expand_path(File.join(File.dirname(__FILE__),".."))
-    LIB_DIR         = File.join(ROOT_DIR,"lib").freeze
-    RESOURCE_DIR    = File.join(ROOT_DIR,"resources").freeze
-    
-    # 
-    # Utility method to require all files ending in .rb in the directory
-    # with the same name as this file minus .rb
+  #
+  # 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
     #
-    def 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 
-    module_function :require_all_libs_relative_to
-    
-    class << self
-        def open(*params)
-            begin
-                klass = Launchy::Application.find_application_class_for(*params)
-                if klass then 
-                    klass.run(*params)
-                else
-                    msg = "Unable to launch #{params.join(' ')}"
-                    Launchy.log "#{self.name} : #{msg}"
-                    $stderr.puts msg
-                end
-            rescue Exception => e
-                msg = "Failure in opening #{params.join(' ')} : #{e}"
-                Launchy.log "#{self.name} : #{msg}"
-                $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
-        end
-        
-        # Create an instance of the commandline application of launchy
-        def command_line
-            Launchy::CommandLine.new
+    # Convenience method to launch an item
+    #
+    def open(*params)
+      begin
+        klass = Launchy::Application.find_application_class_for(*params)
+        if klass then
+          klass.run(*params)
+        else
+          msg = "Unable to launch #{params.join(' ')}"
+          Launchy.log "#{self.name} : #{msg}"
+          $stderr.puts msg
         end
+      rescue Exception => e
+        msg = "Failure in opening #{params.join(' ')} : #{e}"
+        Launchy.log "#{self.name} : #{msg}"
+        $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
+    end
+
+    # Create an instance of the commandline application of launchy
+    def command_line
+      Launchy::CommandLine.new
     end
-    
-    
+  end
 end
 
 Launchy.require_all_libs_relative_to(__FILE__)

data/lib/launchy/application.rb

@@ -1,163 +1,174 @@
 require 'rbconfig'
 
 module Launchy
-    class Application
-        
-        KNOWN_OS_FAMILIES = [ :windows, :darwin, :nix, :cygwin ]
-        
-        class << self
-            def inherited(sub_class)
-                application_classes << sub_class
-            end            
-            def application_classes
-                @application_classes ||= []
-            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
-                end
-            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?
-                paths.each do |path|
-                    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(', ')}"
-                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
-                else
-                    $stderr.puts "Unknown OS familiy for '#{test_os}'.  Please report this bug to #{Launchy::SPEC.email}"
-                    family = :unknown
-                end
-            end
-        end
+  class Application
+    class << self
+      def known_os_families
+        @known_os_families ||= [ :windows, :darwin, :nix, :cygwin ]
+      end
 
+      def inherited(sub_class)
+        application_classes << sub_class
+      end
+      def application_classes
+        @application_classes ||= []
+      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 @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
-        end
-        
-        # find an executable in the available paths
-        def find_executable(bin,*paths)
-            Application.find_executable(bin,*paths)
+      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
         end
-        
-        # return the current 'host_os' string from ruby's configuration
-        def my_os
-            Application.my_os
+      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?
+        paths.each do |path|
+          file = File.join(path,bin)
+          if File.executable?(file) then
+            Launchy.log "#{self.name} : found executable #{file}"
+            return file
+          end
         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)
+        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
-        
-        # 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
+
+      # 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
+        else
+          $stderr.puts "Unknown OS familiy for '#{test_os}'.  Please report this bug to <jeremy at hinegardner dot org>"
+          family = :unknown
         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
+    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
-        
-        # 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."
+        Launchy.log "#{self.class.name} : nix_desktop_environment => '#{@nix_desktop_environment}'"
+      end
+      return @nix_desktop_environment
+    end
+
+    # find an executable in the available 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
+
+    # 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
+        #       running the filename via "cmd /c" is the same as
+        #       running "start filename" at the command-prompt
+        #
+        #       furthermore, 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', *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
-        
-        # 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
-        
-        # run the command
-        def run(cmd,*args)
-            args.unshift(cmd)
-            cmd_line = args.join(' ')
-            Launchy.log "#{self.class.name} : Spawning on #{my_os_family} : #{cmd_line}"
-            
-            if my_os_family == :windows then
-                system cmd_line
-            else
-                # fork, and the child process should NOT run any exit handlers
-                child_pid = fork do 
-                                cmd_line += " > /dev/null 2>&1"
-                                system cmd_line
-                                exit! 
-                            end
-                Process.detach(child_pid)
-            end
-        end
+        Process.detach(child_pid)
+      end
     end
+  end
 end