launchy 0.2.1 → 0.3.0

data/CHANGES

@@ -1,5 +1,12 @@
 == Changes
 
+=== 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
 
 * fix inability to find windows executables [Bug #13132]

data/README

@@ -22,15 +22,15 @@ Currently only launching a browser is supported.
 
 From within your ruby code you can trust launchy to do the right thing:
 
-    Launchy.do_magic("http://www.ruby-lang.org/")
+    Launchy.open("http://www.ruby-lang.org/")
 
 Or, if you want to launch the application yourself:
 
-    Launchy::Spawnable::Browser.run("http://www.ruby-lang.org/")
+    Launchy::Browser.run("http://www.ruby-lang.org/")
 
 OR
 
-    Launchy::Spawnable::Browser.new.visit("http://www.ruby-lang.org/")
+    Launchy::Browser.new.visit("http://www.ruby-lang.org/")
 
 == LICENSE
 

data/bin/launchy

@@ -9,4 +9,4 @@ rescue LoadError
     retry
 end
 
-Launchy.do_magic(*ARGV)
+Launchy.open(*ARGV)

data/lib/launchy.rb

@@ -21,8 +21,8 @@ module Launchy
     module_function :require_all_libs_relative_to
     
     class << self
-        def do_magic(*params)
-            klass = Launchy::Spawnable::Application.find_application_class_for(*params)
+        def open(*params)
+            klass = Launchy::Application.find_application_class_for(*params)
             if klass then 
                 klass.run(*params)
             else

data/lib/launchy/application.rb

@@ -0,0 +1,158 @@
+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 "finding application classes for [#{args.join(' ')}]"
+                application_classes.find do |klass| 
+                    if klass.handle?(*args) then
+                        Launchy.log "  #{klass.name}"
+                        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 "found executable #{file}"
+                        return file
+                    end
+                end
+                Launchy.log "Unable to find `#{bin}' in paths #{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 "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 /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 /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
+
+
+        # 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 "nix_desktop_environment => #{@nix_dekstop_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 "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 "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 "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 "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
+    end
+end

data/lib/launchy/browser.rb

@@ -0,0 +1,80 @@
+require 'launchy/application'
+require 'uri'
+
+module Launchy
+    class Browser < Application
+        
+        DESKTOP_ENVIRONMENT_BROWSER_LAUNCHERS = {
+            :kde     => "kfmclient",
+            :gnome   => "gnome-open",
+            :xfce    => "exo-open",
+            :generic => "htmlview"
+        }
+        
+        FALLBACK_BROWSERS = %w[ firefox seamonkey opera mozilla netscape galeon ]
+        
+        class << self
+            def run(*args)
+                Browser.new.visit(args[0]) 
+            end
+            
+            # return true if this class can handle the given parameter(s)
+            def handle?(*args)
+                begin 
+                    uri = URI.parse(args[0])
+                    return [URI::HTTP, URI::HTTPS, URI::FTP].include?(uri.class)
+                rescue Exception 
+                    return false
+                end
+            end
+        end
+        
+        def initialize
+            raise "Unable to find browser to launch for os family '#{my_os_family}'." unless browser
+        end                        
+            
+        # Find a list of potential browser applications to run on *nix machines.  
+        # The order is:
+        #     1) What is in ENV['LAUNCHY_BROWSER'] or ENV['BROWSER']
+        #     2) xdg-open
+        #     3) desktop environment launcher program
+        #     4) a list of fallback browsers
+        def nix_app_list
+            if not @nix_app_list then
+                browser_cmds = ['xdg-open']
+                browser_cmds << DESKTOP_ENVIRONMENT_BROWSER_LAUNCHERS[nix_desktop_environment]
+                browser_cmds << FALLBACK_BROWSERS
+                browser_cmds.flatten!
+                browser_cmds.delete_if { |b| b.nil? || (b.strip.size == 0) }
+                Launchy.log "Initial *Nix Browser List: #{browser_cmds.join(', ')}"
+                @nix_app_list = browser_cmds.collect { |bin| find_executable(bin) }.find_all { |x| not x.nil? }
+                Launchy.log "Filtered *Nix Browser List: #{@nix_app_list.join(', ')}"
+            end
+            @nix_app_list
+        end
+                                
+        # return the full command line path to the browser or nil
+        def browser
+            if not @browser then
+                if ENV['LAUNCHY_BROWSER'] and File.exists?(ENV['LAUNCHY_BROWSER']) then
+                    Launchy.log "Using LAUNCHY_BROWSER environment variable : #{ENV['LAUNCHY_BROWSER']}"
+                    @browser = ENV['LAUNCHY_BROWSER']
+                elsif ENV['BROWSER'] and File.exists?(ENV['BROWSER']) then
+                    Launchy.log "Using BROWSER environment variable : #{ENV['BROWSER']}"
+                    @browser = ENV['BROWSER']
+                elsif app_list.size > 0 then
+                    @browser = app_list.first
+                    Launchy.log "Using application list : #{@browser}"
+                else
+                    $stderr.puts "Unable to launch. No Browser application found."
+                end
+            end
+            return @browser
+        end
+        
+        # launch the browser at the appointed url
+        def visit(url)
+            run(browser,url)
+        end
+    end
+end

data/lib/launchy/version.rb

@@ -1,8 +1,8 @@
 module Launchy
     class Version
         MAJOR   = 0
-        MINOR   = 2
-        BUILD   = 1
+        MINOR   = 3
+        BUILD   = 0
 
         class << self
             def to_a

data/spec/{spawnable_application_spec.rb → application_spec.rb}

@@ -1,17 +1,17 @@
 require File.join(File.dirname(__FILE__),"spec_helper.rb")
 require 'yaml'
 
-describe Launchy::Spawnable::Application do
+describe Launchy::Application do
     before(:each) do
         yml = YAML::load(IO.read(File.join(File.dirname(__FILE__),"tattle-host-os.yml")))
         @host_os = yml['host_os']
-        @app = Launchy::Spawnable::Application.new
+        @app = Launchy::Application.new
         
     end
 
     it "should find all tattled os" do
         @host_os.keys.each do |os|
-            Launchy::Spawnable::Application::KNOWN_OS_FAMILIES.should include(@app.my_os_family(os))
+            Launchy::Application::KNOWN_OS_FAMILIES.should include(@app.my_os_family(os))
         end
     end
     
@@ -33,6 +33,6 @@ describe Launchy::Spawnable::Application do
     end
     
     it "should find the correct class to launch an ftp url" do
-        Launchy::Spawnable::Application.find_application_class_for("ftp://ftp.ruby-lang.org/pub/ruby/").should == Launchy::Spawnable::Browser
+        Launchy::Application.find_application_class_for("ftp://ftp.ruby-lang.org/pub/ruby/").should == Launchy::Browser
     end
 end

data/spec/browser_spec.rb

@@ -1,23 +1,23 @@
 require File.join(File.dirname(__FILE__),"spec_helper.rb")
 
-describe Launchy::Spawnable::Browser do
+describe Launchy::Browser do
     it "should find a path to a executable" do
-        File.executable?(Launchy::Spawnable::Browser.new.browser).should == true
+        File.executable?(Launchy::Browser.new.browser).should == true
     end
     
     it "should handle an http url" do
-        Launchy::Spawnable::Browser.handle?("http://www.example.com") == true
+        Launchy::Browser.handle?("http://www.example.com") == true
     end
     
     it "should handle an https url" do
-        Launchy::Spawnable::Browser.handle?("https://www.example.com") == true
+        Launchy::Browser.handle?("https://www.example.com") == true
     end
     
     it "should handle an ftp url" do
-        Launchy::Spawnable::Browser.handle?("ftp://download.example.com") == true
+        Launchy::Browser.handle?("ftp://download.example.com") == true
     end
     
     it "should not handle a mailto url" do
-        Launchy::Spawnable::Browser.handle?("mailto:jeremy@example.com") == false
+        Launchy::Browser.handle?("mailto:jeremy@example.com") == false
     end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
+rubygems_version: 0.9.2
 specification_version: 1
 name: launchy
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
-date: 2007-08-18 00:00:00 -06:00
+  version: 0.3.0
+date: 2007-08-30 00:00:00 -06:00
 summary: A helper to launch apps from within ruby programs.
 require_paths: 
 - lib
@@ -29,24 +29,23 @@ post_install_message:
 authors: 
 - Jeremy Hinegardner
 files: 
+- spec/application_spec.rb
 - spec/browser_spec.rb
-- spec/spawnable_application_spec.rb
 - spec/spec_helper.rb
 - spec/version_spec.rb
 - CHANGES
 - LICENSE
 - README
+- lib/launchy/application.rb
+- lib/launchy/browser.rb
 - lib/launchy/gemspec.rb
-- lib/launchy/spawnable/application.rb
-- lib/launchy/spawnable/browser.rb
-- lib/launchy/spawnable.rb
 - lib/launchy/specification.rb
 - lib/launchy/version.rb
 - lib/launchy.rb
 - bin/launchy
 test_files: 
+- spec/application_spec.rb
 - spec/browser_spec.rb
-- spec/spawnable_application_spec.rb
 - spec/spec_helper.rb
 - spec/version_spec.rb
 rdoc_options: 

data/lib/launchy/spawnable.rb

@@ -1,2 +0,0 @@
-require 'launchy/spawnable/application'
-require 'launchy/spawnable/browser'

data/lib/launchy/spawnable/application.rb

@@ -1,150 +0,0 @@
-require 'launchy/spawnable'
-require 'rbconfig'
-
-module Launchy
-    module Spawnable
-        class Application
-            
-            KNOWN_OS_FAMILIES = [ :windows, :darwin, :nix ]
-            
-            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 "finding application classes for [#{args.join(' ')}]"
-                    application_classes.find do |klass| 
-                        if klass.handle?(*args) then
-                            Launchy.log "  #{klass.name}"
-                            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 "found executable #{file}"
-                            return file
-                        end
-                    end
-                    Launchy.log "Unable to find `#{bin}' in paths #{paths.join(', ')}"
-                    return nil
-                end
-                
-                # return the current 'host_os' string from ruby's configuration
-                def my_os
-                    ::Config::CONFIG['host_os']
-                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 /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 /cygwin/i
-                        family = :nix
-                    else
-                        $stderr.puts "Unknown OS familiy for '#{test_os}'.  Please report this bug to #{Launchy::SPEC.email}"
-                        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 @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 "nix_desktop_environment => #{@nix_dekstop_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 or :nix
-            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 "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 "Using 'start' command on windows."
-                %w[ start ]
-            end
-            
-            # run the command
-            def run(cmd,*args)
-                args.unshift(cmd)
-                cmd_line = args.join(' ')
-                Launchy.log "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
-        end
-    end
-end

data/lib/launchy/spawnable/browser.rb

@@ -1,83 +0,0 @@
-require 'launchy/spawnable/application'
-require 'uri'
-
-module Launchy
-    module Spawnable
-        class Browser < Application
-            
-            DESKTOP_ENVIRONMENT_BROWSER_LAUNCHERS = {
-                :kde     => "kfmclient",
-                :gnome   => "gnome-open",
-                :xfce    => "exo-open",
-                :generic => "htmlview"
-            }
-            
-            FALLBACK_BROWSERS = %w[ firefox seamonkey opera mozilla netscape galeon ]
-            
-            class << self
-                def run(*args)
-                    Browser.new.visit(args[0]) 
-                end
-                
-                # return true if this class can handle the given parameter(s)
-                def handle?(*args)
-                    begin 
-                        uri = URI.parse(args[0])
-                        return [URI::HTTP, URI::HTTPS, URI::FTP].include?(uri.class)
-                    rescue Exception 
-                        return false
-                    end
-                end
-            end
-            
-            def initialize
-                raise "Unable to find browser to launch for os family '#{my_os_family}'." unless browser
-            end                        
-                
-            # Find a list of potential browser applications to run on *nix machines.  
-            # The order is:
-            #     1) What is in ENV['LAUNCHY_BROWSER'] or ENV['BROWSER']
-            #     2) xdg-open
-            #     3) desktop environment launcher program
-            #     4) a list of fallback browsers
-            def nix_app_list
-                if not @nix_app_list then
-                    browser_cmds = ['xdg-open']
-                    browser_cmds << DESKTOP_ENVIRONMENT_BROWSER_LAUNCHERS[nix_desktop_environment]
-                    browser_cmds << FALLBACK_BROWSERS
-                    browser_cmds.flatten!
-                    browser_cmds.delete_if { |b| b.nil? || (b.strip.size == 0) }
-                    Launchy.log "Initial *Nix Browser List: #{browser_cmds.join(', ')}"
-                    @nix_app_list = browser_cmds.collect { |bin| find_executable(bin) }.find_all { |x| not x.nil? }
-                    Launchy.log "Filtered *Nix Browser List: #{@nix_app_list.join(', ')}"
-                end
-                @nix_app_list
-            end
-                                    
-            # return the full command line path to the browser or nil
-            def browser
-                if not @browser then
-                    if ENV['LAUNCHY_BROWSER'] and File.exists?(ENV['LAUNCHY_BROWSER']) then
-                        Launchy.log "Using LAUNCHY_BROWSER environment variable : #{ENV['LAUNCHY_BROWSER']}"
-                        @browser = ENV['LAUNCHY_BROWSER']
-                    elsif ENV['BROWSER'] and File.exists?(ENV['BROWSER']) then
-                        Launchy.log "Using BROWSER environment variable : #{ENV['BROWSER']}"
-                        @browser = ENV['BROWSER']
-                    elsif app_list.size > 0 then
-                        @browser = app_list.first
-                        Launchy.log "Using application list : #{@browser}"
-                    else
-                        $stderr.puts "Unable to launch. No Browser application found."
-                    end
-                end
-                return @browser
-            end
-            
-            # launch the browser at the appointed url
-            def visit(url)
-                run(browser,url)
-            end
-            
-        end
-    end
-end