wijet-launchy 2.0.6

data/lib/launchy/applications/browser.rb

@@ -0,0 +1,79 @@
+class Launchy::Application
+  #
+  # The class handling the browser application and all of its schemes
+  #
+  class Browser < Launchy::Application
+    def self.schemes
+      %w[ http https ftp file ]
+    end
+
+    def self.handles?( uri )
+      return true if schemes.include?( uri.scheme )
+      return true if File.exist?( uri.path )
+    end
+
+    def windows_app_list
+      [ 'start /b' ]
+    end
+
+    def cygwin_app_list
+      [ 'cmd /C start /b' ]
+    end
+
+    def darwin_app_list
+      [ find_executable( "open" ) ]
+    end
+
+    def nix_app_list
+      app_list = %w[ xdg-open ]
+      if nix_de = Launchy::Detect::NixDesktopEnvironment.detect then
+        app_list << nix_de.browser
+        app_list << nix_de.fallback_browsers
+      end
+      app_list.flatten!
+      app_list.delete_if { |b| b.nil? || (b.strip.size == 0) }
+      app_list.collect { |bin| find_executable( bin ) }.find_all { |x| not x.nil? }
+    end
+
+    # use a call back mechanism to get the right app_list that is decided by the 
+    # host_os_family class.
+    def app_list
+      host_os_family.app_list( self )
+    end
+
+    def browser_env
+      return [] unless ENV['BROWSER']
+      browser_env = ENV['BROWSER'].split( File::PATH_SEPARATOR )
+      browser_env.flatten!
+      browser_env.delete_if { |b| b.nil? || (b.strip.size == 0) }
+      return browser_env
+    end
+
+    # Get the full commandline of what we are going to add the uri to
+    def browser_cmdline
+      possibilities = (browser_env + app_list).flatten
+      possibilities.each do |p|
+        Launchy.log "#{self.class.name} : possibility : #{p}"
+      end
+      browser = possibilities.shift
+      Launchy.log "#{self.class.name} : Using browser value '#{browser}'"
+      return browser
+    end
+
+    def cmd_and_args( uri, options = {} )
+      cmd = browser_cmdline
+      args = [ uri.to_s ]
+      if cmd =~ /%s/ then
+        cmd.gsub!( /%s/, args.shift )
+      end
+      return [cmd, args]
+    end
+
+    # final assembly of the command and do %s substitution 
+    # http://www.catb.org/~esr/BROWSER/index.html
+    def open( uri, options = {} )
+      cmd, args = cmd_and_args( uri, options )
+      run( cmd, args )
+    end
+  end
+end

data/lib/launchy/cli.rb

@@ -0,0 +1,83 @@
+require 'optparse'
+
+module Launchy
+  class Cli
+
+    attr_reader :options
+    def initialize
+      @options = {}
+    end
+  
+    def parser
+      @parser ||= OptionParser.new do |op|
+        op.banner = "Usage: launchy [options] thing-to-launch"
+
+        op.separator ""
+        op.separator "Launch Options:"
+
+        op.on( "-a", "--application APPLICATION", 
+               "Explicitly specify the application class to use in the launch") do |app|
+          @options[:application] = app
+        end
+
+        op.on( "-d", "--debug", 
+               "Force debug. Output lots of information.") do |d|
+          @options[:debug] = 'true'
+        end
+
+        op.on( "-e", "--engine RUBY_ENGINE",
+               "Force launchy to behave as if it was on a particular ruby engine.") do |e|
+          @options[:ruby_engine] = e
+        end
+
+        op.on( "-n", "--dry-run", "Don't launchy, print the command to be executed on stdout" ) do |x|
+          @options[:dry_run] = true
+        end
+
+        op.on( "-o", "--host-os HOST_OS", 
+               "Force launchy to behave as if it was on a particular host os.") do |os|
+          @options[:host_os] = os
+        end
+
+
+        op.separator ""
+        op.separator "Standard Options:"
+
+        op.on( "-h", "--help", "Print this message.") do |h|
+          $stdout.puts op.to_s
+          exit 0
+        end
+
+        op.on( "-v", "--version", "Output the version of Launchy") do |v|
+          $stdout.puts "Launchy version #{Launchy::VERSION}"
+          exit 0
+        end
+
+      end
+    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
+    end
+
+    def good_run( argv, env )
+      if parse( argv, env ) then
+        Launchy.open( argv.shift, options )
+        return true
+      else
+        return false
+      end
+    end
+
+    def run( argv = ARGV, env = ENV )
+      exit 1 unless good_run( argv, env )
+    end
+  end
+end

data/lib/launchy/deprecated.rb

@@ -0,0 +1,52 @@
+module Launchy
+  #
+  # This class is deprecated and will be removed 
+  #
+  class Browser
+    def self.run( *args )
+      Browser.new.visit( args[0] )
+    end
+
+    def visit( url )
+      _warn "You made a call to a deprecated Launchy API. This call should be changed to 'Launchy.open( uri )'"
+      report_caller_context( caller )
+
+      ::Launchy.open( url )
+    end
+
+    private
+
+    def find_caller_context( stack )
+      caller_file = stack.find do |line|
+        not line.index( __FILE__ )
+      end
+      if caller_file then
+        caller_fname, caller_line, _ = caller_file.split(":")
+        if File.readable?( caller_fname ) then
+          caller_lines = IO.readlines( caller_fname )
+          context = [ caller_file ]
+          context << caller_lines[(caller_line.to_i)-3, 5] 
+          return context.flatten
+        end
+      end
+      return []
+    end
+
+    def report_caller_context( stack )
+      context = find_caller_context( stack )
+      if context.size > 0 then
+        _warn "I think I was able to find the location that needs to be fixed. Please go look at:"
+        _warn
+        context.each do |line|
+          _warn line.rstrip
+        end
+        _warn
+        _warn "If this is not the case, please file a bug. #{Launchy.bug_report_message}"
+      end
+    end
+
+    def _warn( msg = "" )
+      warn "WARNING: #{msg}"
+    end
+  end
+end

data/lib/launchy/descendant_tracker.rb

@@ -0,0 +1,49 @@
+require 'set'
+
+module Launchy
+  #
+  # Use by either
+  #
+  #   class Foo
+  #     extend DescendantTracker
+  #   end
+  #
+  # or
+  #   
+  #   class Foo
+  #     class << self
+  #       include DescendantTracker
+  #     end
+  #   end
+  #
+  # It will track all the classes that inherit from the extended class and keep
+  # them in a Set that is available via the 'children' method.
+  #
+  module DescendantTracker
+    def inherited( klass )
+      return unless klass.instance_of?( Class )
+      self.children << klass
+    end
+
+    #
+    # The list of children that are registered
+    #
+    def children
+      unless defined? @children
+        @children = Set.new
+      end
+      return @children
+    end
+
+    #
+    # Find one of the child classes by calling the given method
+    # and passing all the rest of the parameters to that method in 
+    # each child
+    def find_child( method, *args )
+      klass = children.find do |child|
+        Launchy.log "Checking if class #{child} is the one for #{method}(#{args.join(', ')})}"
+        child.send( method, *args )
+      end
+    end
+  end
+end

data/lib/launchy/detect.rb

@@ -0,0 +1,10 @@
+module Launchy
+  module Detect
+  end
+end
+
+require 'launchy/detect/host_os'
+require 'launchy/detect/host_os_family'
+require 'launchy/detect/ruby_engine'
+require 'launchy/detect/nix_desktop_environment'
+require 'launchy/detect/runner'

data/lib/launchy/detect/host_os.rb

@@ -0,0 +1,31 @@
+require 'rbconfig'
+
+module Launchy::Detect
+  class HostOs
+
+    attr_reader :host_os
+    alias to_s host_os
+
+    def initialize( host_os = nil )
+      @host_os = host_os
+
+      if not @host_os then
+        if @host_os = override_host_os then
+          Launchy.log "Using LAUNCHY_HOST_OS override value of '#{Launchy.host_os}'"
+        else
+          @host_os = default_host_os
+        end
+      end
+    end
+
+    def default_host_os
+      ::RbConfig::CONFIG['host_os']
+    end
+
+    def override_host_os
+      Launchy.host_os
+    end
+
+  end
+
+end

data/lib/launchy/detect/host_os_family.rb

@@ -0,0 +1,71 @@
+module Launchy::Detect
+  # Detect the current host os family
+  #
+  # If the current host familiy cannot be detected then return
+  # HostOsFamily::Unknown
+  class HostOsFamily
+    class NotFoundError < Launchy::Error; end
+    extend ::Launchy::DescendantTracker
+
+    class << self
+
+      def detect( host_os = HostOs.new )
+        found = find_child( :matches?, host_os )
+        return found.new( host_os ) if found
+        raise NotFoundError, "Unknown OS family for host os '#{host_os}'. #{Launchy.bug_report_message}"
+      end
+
+      def matches?( host_os )
+        matching_regex.match( host_os.to_s )
+      end
+
+      def windows?() self == Windows; end
+      def darwin?()  self == Darwin;  end
+      def nix?()     self == Nix;     end
+      def cygwin?()  self == Cygwin;  end
+    end
+
+
+    attr_reader :host_os
+    def initialize( host_os = HostOs.new )
+      @host_os = host_os
+    end
+
+    def windows?() self.class.windows?; end
+    def darwin?()  self.class.darwin?;  end
+    def nix?()     self.class.nix?;      end
+    def cygwin?()  self.class.cygwin?;  end
+
+    #---------------------------
+    # All known host os families
+    #---------------------------
+    #
+    class Windows < HostOsFamily
+      def self.matching_regex
+        /(mingw|mswin|windows)/i
+      end
+      def app_list( app ) app.windows_app_list; end
+    end
+
+    class Darwin < HostOsFamily
+      def self.matching_regex
+        /(darwin|mac os)/i
+      end
+      def app_list( app ) app.darwin_app_list; end
+    end
+
+    class Nix < HostOsFamily
+      def self.matching_regex
+        /(linux|bsd|aix|solaris)/i
+      end
+      def app_list( app ) app.nix_app_list; end
+    end
+
+    class Cygwin < HostOsFamily
+      def self.matching_regex
+        /cygwin/i
+      end
+      def app_list( app ) app.cygwin_app_list; end
+    end
+  end
+end

data/lib/launchy/detect/nix_desktop_environment.rb

@@ -0,0 +1,60 @@
+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
+  class NixDesktopEnvironment
+    class NotFoundError < Launchy::Error; end
+
+    extend ::Launchy::DescendantTracker
+
+    # Detect the current *nix desktop environment
+    #
+    # If the current dekstop environment be detected, the return
+    # NixDekstopEnvironment::Unknown
+    def self.detect
+      found = find_child( :is_current_desktop_environment? )
+      Launchy.log("Current Desktop environment not flound. #{Launchy.bug_report_message}") unless found
+      return found
+    end
+
+    def self.fallback_browsers
+      %w[ firefox seamonkey opera mozilla netscape galeon ]
+    end
+
+    #---------------------------------------
+    # The list of known desktop environments
+    #---------------------------------------
+
+    class Kde < NixDesktopEnvironment
+      def self.is_current_desktop_environment?
+        ENV['KDE_FULL_SESSION']
+      end
+
+      def self.browser
+        'kfmclient'
+      end
+    end
+
+    class Gnome < NixDesktopEnvironment
+      def self.is_current_desktop_environment?
+        ENV['GNOME_DESKTOP_SESSION_ID']
+      end
+
+      def self.browser
+        'gnome-open'
+      end
+    end
+
+    class Xfce < NixDesktopEnvironment
+      def self.is_current_desktop_environment?
+        %x[ xprop -root _DT_SAVE_MODE | grep ' = \"xfce\"$' ].strip.size > 0
+      end
+
+      def self.browser
+        'exo-open'
+      end
+    end
+  end
+end
+

data/lib/launchy/detect/ruby_engine.rb

@@ -0,0 +1,78 @@
+module Launchy::Detect
+  class RubyEngine
+    class NotFoundError < Launchy::Error; end
+
+    extend ::Launchy::DescendantTracker
+
+    # Detect the current ruby engine.
+    #
+    # If the current ruby engine cannot be detected, the return
+    # RubyEngine::Unknown
+    def self.detect( ruby_engine = RubyEngine.new )
+      found = find_child( :is_current_engine?, ruby_engine.to_s )
+      return found if found
+      raise NotFoundError, "#{ruby_engine_error_message( ruby_engine )} #{Launchy.bug_report_message}"
+    end
+
+    def self.ruby_engine_error_message( ruby_engine )
+      msg = "Unkonwn RUBY_ENGINE "
+      if ruby_engine then
+        msg += " '#{ruby_engine}'."
+      elsif defined?( RUBY_ENGINE ) then
+        msg += " '#{RUBY_ENGINE}'."
+      else
+        msg = "RUBY_ENGINE not defined for #{RUBY_DESCRIPTION}."
+      end
+      return msg
+    end
+
+    def self.is_current_engine?( ruby_engine )
+      return ruby_engine == self.engine_name
+    end
+
+    def self.mri?()     self == Mri;     end
+    def self.jruby?()   self == Jruby;   end
+    def self.rbx?()     self == Rbx;     end
+    def self.macruby?() self == MacRuby; end
+
+    attr_reader :ruby_engine
+    alias to_s ruby_engine
+    def initialize( ruby_engine = Launchy.ruby_engine )
+      if ruby_engine then
+        @ruby_engine = ruby_engine
+      else
+        @ruby_engine = defined?( RUBY_ENGINE ) ? RUBY_ENGINE : "ruby"
+      end
+    end
+
+
+    #-------------------------------
+    # The list of known ruby engines
+    #-------------------------------
+
+    #
+    # This is the ruby engine if the RUBY_ENGINE constant is not defined
+    class Mri < RubyEngine
+      def self.engine_name() "ruby"; end
+      def self.is_current_engine?( ruby_engine )
+        if ruby_engine then
+          super( ruby_engine )
+        else
+          return true if not Launchy.ruby_engine and not defined?( RUBY_ENGINE )
+        end
+      end
+    end
+
+    class Jruby < RubyEngine
+      def self.engine_name() "jruby"; end
+    end
+
+    class Rbx < RubyEngine
+      def self.engine_name() "rbx"; end
+    end
+
+    class MacRuby < RubyEngine
+      def self.engine_name() "macruby"; end
+    end
+  end
+end