launchy 0.3.2 → 0.3.3

data/lib/launchy/browser.rb

@@ -2,84 +2,97 @@ require 'launchy/application'
 require 'uri'
 
 module Launchy
-    class Browser < Application
-        
-        DESKTOP_ENVIRONMENT_BROWSER_LAUNCHERS = {
-            :kde     => "kfmclient",
-            :gnome   => "gnome-open",
-            :xfce    => "exo-open",
-            :generic => "htmlview"
+  class Browser < Application
+
+
+    class << self
+      def desktop_environment_browser_launchers
+        @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 
-                    Launchy.log "#{self.name} : testing if [#{args[0]}] (#{args[0].class}) is a url."
-                    uri = URI.parse(args[0])
-                    result =  [URI::HTTP, URI::HTTPS, URI::FTP].include?(uri.class)
-                rescue Exception => e
-                    # hmm... why does rcov not see that this is executed ?
-                    Launchy.log "#{self.name} : not a url, #{e}" 
-                    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 "#{self.class.name} : 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 "#{self.class.name} : 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 "#{self.class.name} : Using LAUNCHY_BROWSER environment variable : #{ENV['LAUNCHY_BROWSER']}"
-                    @browser = ENV['LAUNCHY_BROWSER']
-                elsif ENV['BROWSER'] and File.exists?(ENV['BROWSER']) then
-                    Launchy.log "#{self.class.name} : Using BROWSER environment variable : #{ENV['BROWSER']}"
-                    @browser = ENV['BROWSER']
-                elsif app_list.size > 0 then
-                    @browser = app_list.first
-                    Launchy.log "#{self.class.name} : Using application list : #{@browser}"
-                else
-                    msg = "Unable to launch. No Browser application found."
-                    Launchy.log "#{self.class.name} : #{msg}"
-                    $stderr.puts msg
-                end
-            end
-            return @browser
+      end
+      def fallback_browsers
+        @fallback_browsers ||=  %w[ firefox seamonkey opera mozilla netscape galeon ]
+      end
+      def run(*args)
+        Browser.new.visit(args[0])
+      end
+
+      # return true if this class can handle the given parameter(s)
+      def handle?(*args)
+        begin
+          Launchy.log "#{self.name} : testing if [#{args[0]}] (#{args[0].class}) is a url."
+          uri = URI.parse(args[0])
+          result =  [URI::HTTP, URI::HTTPS, URI::FTP].include?(uri.class)
+        rescue Exception => e
+          # hmm... why does rcov not see that this is executed ?
+          Launchy.log "#{self.name} : not a url, #{e}"
+          return false
         end
-        
-        # launch the browser at the appointed url
-        def visit(url)
-            run(browser,url)
+      end
+    end
+
+    def initialize
+      @browser = nil
+      @nix_app_list = nil
+      raise "Unable to find browser to launch for os family '#{my_os_family}'." unless browser
+    end
+
+    def desktop_environment_browser_launchers
+      self.class.desktop_environment_browser_launchers
+    end
+
+    def fallback_browsers
+      self.class.fallback_browsers
+    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 "#{self.class.name} : 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 "#{self.class.name} : 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 "#{self.class.name} : Using LAUNCHY_BROWSER environment variable : #{ENV['LAUNCHY_BROWSER']}"
+          @browser = ENV['LAUNCHY_BROWSER']
+        elsif ENV['BROWSER'] and File.exists?(ENV['BROWSER']) then
+          Launchy.log "#{self.class.name} : Using BROWSER environment variable : #{ENV['BROWSER']}"
+          @browser = ENV['BROWSER']
+        elsif app_list.size > 0 then
+          @browser = app_list.first
+          Launchy.log "#{self.class.name} : Using application list : #{@browser}"
+        else
+          msg = "Unable to launch. No Browser application found."
+          Launchy.log "#{self.class.name} : #{msg}"
+          $stderr.puts msg
         end
+      end
+      return @browser
+    end
+
+    # launch the browser at the appointed url
+    def visit(url)
+      run(browser,url)
     end
+  end
 end

data/lib/launchy/command_line.rb

@@ -1,48 +1,48 @@
 require 'optparse'
 
 module Launchy
-    class CommandLine
+  class CommandLine
 
-        def parser
-            @parser ||= OptionParser.new do |op|
-                            op.banner = "Usage: launchy [options] url"
-                            op.separator ""
-                            op.on("-d", "--debug", "Force debug, output lots of information.",
-                                        "This sets the LAUNCHY_DEBUG environment variable to 'true'.") do |d|
-                                ENV["LAUNCHY_DEBUG"] = 'true'
-                            end
-                        
-                            op.on("-h", "--help", "Print this message") do |h|
-                                puts op.to_s
-                                exit 0
-                            end
+    def parser
+      @parser ||= OptionParser.new do |op|
+        op.banner = "Usage: launchy [options] url"
+        op.separator ""
+        op.on("-d", "--debug", "Force debug, output lots of information.",
+                               "This sets the LAUNCHY_DEBUG environment variable to 'true'.") do |d|
+          ENV["LAUNCHY_DEBUG"] = 'true'
+        end
+
+        op.on("-h", "--help", "Print this message") do |h|
+          puts op.to_s
+          exit 0
+        end
+
+        op.on("-v", "--version", "Output the version of Launchy") do |v|
+          puts "Launchy version #{Launchy::VERSION}"
+          exit 0
+        end
 
-                            op.on("-v", "--version", "Output the version of Launchy") do |v|
-                                puts "Launchy version #{Launchy::VERSION}"
-                                exit 0
-                            end
-                        
-                            op.on("-o", "--host-os HOST_OS","Force the behavior of a particular host os.",
+        op.on("-o", "--host-os HOST_OS","Force the behavior of a particular host os.",
                                     "This sets the LAUNCHY_HOST_OS environment variable.") do |os|
-                                ENV["LAUNCHY_HOST_OS"] = os
-                            end
-                            
-                            op.on("-b", "--browser BROWSER", "Force launchy to use a particular browser.",
-                                   "This sets the LAUNCHY_BROWSER environment variable.") do |browser|
-                                ENV["LAUNCHY_BROWSER"] = browser
-                            end
-                      end
+          ENV["LAUNCHY_HOST_OS"] = os
         end
-        
-        def run(argv = ARGV)
-            begin 
-                parser.parse!(argv)
-                Launchy.open(*argv)
-            rescue ::OptionParser::ParseError => pe
-                $stderr.puts "#{parser.programn_name}: #{pe}"
-                $stderr.puts "Try `#{parser.program_name} --help' for more information."
-                exit 1
-            end
+
+        op.on("-b", "--browser BROWSER", "Force launchy to use a particular browser.",
+                                   "This sets the LAUNCHY_BROWSER environment variable.") do |browser|
+          ENV["LAUNCHY_BROWSER"] = browser
         end
+      end
+    end
+
+    def run(argv = ARGV)
+      begin
+        parser.parse!(argv)
+        Launchy.open(*argv)
+      rescue ::OptionParser::ParseError => pe
+        $stderr.puts "#{parser.programn_name}: #{pe}"
+        $stderr.puts "Try `#{parser.program_name} --help' for more information."
+        exit 1
+      end
     end
+  end
 end

data/lib/launchy/paths.rb

@@ -0,0 +1,53 @@
+#--
+# Copyright (c) 2007 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+#
+module Launchy
+  #
+  # Access to various paths inside the project programatically
+  #
+  module Paths
+    #
+    # :call-seq:
+    #    Launchy::Paths.root_dir -> String
+    #
+    # Returns The full expanded path of the parent directory of +lib+
+    # going up the path from the current file.  A trailing File::SEPARATOR⋅
+    # is guaranteed
+    #
+    def self.root_dir
+      @root_dir ||=(
+        path_parts = ::File.expand_path( __FILE__ ).split( ::File::SEPARATOR )
+        lib_index  = path_parts.rindex( "lib" )
+        @root_dir  = path_parts[0...lib_index].join( ::File::SEPARATOR ) + ::File::SEPARATOR
+      )
+    end
+
+    #
+    # :call-seq:
+    #   Launchy::Paths.lib_path( *args ) -> String
+    #
+    # Returns The full expanded path of the +lib+ directory below
+    # _root_dir_.  All parameters passed in are joined onto the⋅
+    # result. A trailing File::SEPARATOR is guaranteed if⋅
+    # _args_ are *not* present.
+    #
+    def self.lib_path( *args )
+      self.sub_path( "lib", *args )
+    end
+
+    #
+    # :call-seq:
+    #   Launchy::Paths.sub_path( sub, *args ) -> String
+    #
+    # Returns the full expanded path of the +sub+ directory below _root_dir.  All
+    # _arg_ parameters passed in are joined onto the result.  A trailing
+    # File::SEPARATOR is guaranteed if _args_ are *not* present.
+    #
+    def self.sub_path( sub, *args )
+      sp = ::File.join( root_dir, sub ) + File::SEPARATOR
+      sp = ::File.join( sp, *args ) if args
+    end
+  end
+end

data/lib/launchy/version.rb

@@ -1,18 +1,17 @@
 module Launchy
-    class Version
-        MAJOR   = 0
-        MINOR   = 3
-        BUILD   = 2
+  module Version
+    MAJOR   = 0
+    MINOR   = 3
+    BUILD   = 3
 
-        class << self
-            def to_a
-                [MAJOR, MINOR, BUILD]
-            end
+    def self.to_a
+      [MAJOR, MINOR, BUILD]
+    end
 
-            def to_s
-                to_a.join(".")
-            end
-        end
+    def self.to_s
+      to_a.join(".")
     end
-    VERSION = Version.to_s
+    STRING = Version.to_s.freeze
+  end
+  VERSION = Version.to_s.freeze
 end

data/spec/application_spec.rb

@@ -2,58 +2,57 @@ require File.join(File.dirname(__FILE__),"spec_helper.rb")
 require 'yaml'
 
 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::Application.new
-    end
+  before(:each) do
+    yml = YAML::load(IO.read(File.join(File.dirname(__FILE__),"tattle-host-os.yml")))
+    @host_os = yml['host_os']
+    @app = Launchy::Application.new
+  end
 
-    YAML::load(IO.read(File.join(File.dirname(__FILE__), "tattle-host-os.yml")))['host_os'].keys.sort.each do |os|
-      it "#{os} should be a found os" do
-        Launchy::Application::KNOWN_OS_FAMILIES.should include(@app.my_os_family(os))
-      end
-    end
-    
-    it "should not find os of 'dos'" do
-        @app.my_os_family('dos').should == :unknown
-    end
-    
-    it "my os should have a value" do
-        @app.my_os.should_not == ''
-        @app.my_os.should_not == nil
-    end 
-    
-    it "should find open" do    
-        @app.find_executable('open').should == "/usr/bin/open"
-    end
-    
-    it "should not find app xyzzy" do
-        @app.find_executable('xyzzy').should == nil
-    end
-    
-    it "should find the correct class to launch an ftp url" do
-        Launchy::Application.find_application_class_for("ftp://ftp.ruby-lang.org/pub/ruby/").should == Launchy::Browser
-    end
-    
-    it "knows when it cannot find an application class" do
-        Launchy::Application.find_application_class_for("xyzzy:stuff,things").should == nil
-    end
-    
-    it "allows for environmental override of host_os" do
-        ENV["LAUNCHY_HOST_OS"] = "hal-9000"
-        Launchy::Application.my_os.should == "hal-9000"
-        ENV["LAUNCHY_HOST_OS"] = nil
-    end
-    
-    it "can detect the desktop environment of a *nix machien" do
-        @app.nix_desktop_environment.should == :generic
-
-        { "KDE_FULL_SESSION" => :kde,
-          "KDE_SESSION_UID"  => :kde,
-          "GNOME_DESKTOP_SESSION_ID" => :gnome }.each_pair do |k,v|
-            ENV[k] = "launchy-test"
-            Launchy::Application.new.nix_desktop_environment.should == v
-            ENV[k] = nil
-        end
+  YAML::load(IO.read(File.join(File.dirname(__FILE__), "tattle-host-os.yml")))['host_os'].keys.sort.each do |os|
+    it "#{os} should be a found os" do
+      Launchy::Application::known_os_families.should include(@app.my_os_family(os))
     end
+  end
+
+  it "should not find os of 'dos'" do
+    @app.my_os_family('dos').should eql(:unknown)
+  end
+
+  it "my os should have a value" do
+    @app.my_os.should_not eql('')
+    @app.my_os.should_not eql(nil)
+  end
+
+  it "should find open" do
+    @app.find_executable('open').should eql("/usr/bin/open")
+  end
+
+  it "should not find app xyzzy" do
+    @app.find_executable('xyzzy').should eql(nil)
+  end
+
+  it "should find the correct class to launch an ftp url" do
+    Launchy::Application.find_application_class_for("ftp://ftp.ruby-lang.org/pub/ruby/").should == Launchy::Browser
+  end
+
+  it "knows when it cannot find an application class" do
+    Launchy::Application.find_application_class_for("xyzzy:stuff,things").should == nil
+  end
+
+  it "allows for environmental override of host_os" do
+    ENV["LAUNCHY_HOST_OS"] = "hal-9000"
+    Launchy::Application.my_os.should eql("hal-9000")
+    ENV["LAUNCHY_HOST_OS"] = nil
+  end
+
+  { "KDE_FULL_SESSION" => :kde,
+    "KDE_SESSION_UID"  => :kde,
+    "GNOME_DESKTOP_SESSION_ID" => :gnome }.each_pair do |k,v|
+    it "can detect the desktop environment of a *nix machine using #{k}" do
+      @app.nix_desktop_environment.should eql(:generic)
+      ENV[k] = "launchy-test"
+      Launchy::Application.new.nix_desktop_environment.should eql(v)
+      ENV[k] = nil
+    end
+  end
 end